Colors.c

Go to the documentation of this file.

#include <stdlib.h>
#include <limits.h>
#include "errors.h"
#include "Graph.h"
#include "Binary.h"
 
#include <stdio.h>
 
#define COLOR_CLUSTER_LENGTH 2
#define CHANNEL_SOURCES_LENGTH 3
#define CHANNEL_CLUSTER_LENGTH 3
 
struct Colors {
    struct Binary *binary;
    struct Graph *graph;
    unsigned int *colorCache;
    unsigned int colorType;
    unsigned int colorDepth;
};
 
struct Colors *Colors_construct(unsigned int colorType, struct Binary *binary, struct Graph *graph, int *error)
{
    struct Colors *this = malloc(sizeof(struct Colors));
 
    if (0 == this) {
        *error = ERROR_NO_MEMORY;
        return 0;
    }
 
    this->binary = binary;
    this->graph = graph;
    this->colorType = colorType;
    this->colorDepth = UCHAR_MAX + 1;
 
    this->colorCache = calloc(this->colorDepth * this->colorDepth * this->colorDepth, sizeof(unsigned int));
 
    if (0 == this->colorCache) {
        *error = ERROR_NO_MEMORY;
        return 0;
    }
 
    return this;
}
 
struct Colors *Colors_destruct(struct Colors *this)
{
    if (0 != this) {
        Binary_destruct(this->binary);
        free(this->colorCache);
        free(this);
    }
 
    return 0;
}
 
void Colors_initialize(struct Colors *this, int *error)
{
    unsigned int length = this->colorDepth * this->colorDepth * this->colorDepth;
    unsigned int *colorTypes = calloc(length, sizeof(unsigned int));
 
    Graph_readTargets(this->graph, this->colorType, length, colorTypes, error);
 
    if (*error) {
        return;
    }
    unsigned int colorCluster[COLOR_CLUSTER_LENGTH];
    unsigned int colorSources[CHANNEL_SOURCES_LENGTH];
    unsigned int redCluster[CHANNEL_CLUSTER_LENGTH];
    unsigned int greenCluster[CHANNEL_CLUSTER_LENGTH];
    unsigned int blueCluster[CHANNEL_CLUSTER_LENGTH];
 
    for (unsigned int index = 0; index < length; index ++) {
 
        unsigned int colorType = colorTypes[index];
 
        if (0 == colorType) {
            break;
        }
 
        Graph_readCluster(this->graph, colorType, COLOR_CLUSTER_LENGTH, colorCluster, error);
 
        if (*error) {
            return;
        }
 
        unsigned int color = colorCluster[1];
 
        Graph_readSources(this->graph, color, CHANNEL_SOURCES_LENGTH, colorSources, error);
 
        if (*error) {
            return;
        }
 
        // red
 
        Graph_readCluster(this->graph, colorSources[2], CHANNEL_CLUSTER_LENGTH, redCluster, error);
 
        if (*error) {
            return;
        }
 
        unsigned char redValue = Binary_readCode(this->binary, redCluster[0], error);
 
        if (*error) {
            return;
        }
 
        // green
 
        Graph_readCluster(this->graph, colorSources[2], CHANNEL_CLUSTER_LENGTH, greenCluster, error);
 
        if (*error) {
            return;
        }
 
        unsigned char greenValue = Binary_readCode(this->binary, greenCluster[1], error);
 
        if (*error) {
            return;
        }
 
        // blue
 
        Graph_readCluster(this->graph, colorSources[2], CHANNEL_CLUSTER_LENGTH, blueCluster, error);
 
        if (*error) {
            return;
        }
 
        unsigned char blueValue = Binary_readCode(this->binary, blueCluster[2], error);
 
        if (*error) {
            return;
        }
 
        // colorCache
 
        unsigned int index = (redValue << 16) | (greenValue << 8) | blueValue;
 
        this->colorCache[index] = color;
    }
 
    free(colorTypes);
}
 
unsigned int Colors_writeColor(struct Colors *this, unsigned char redValue, unsigned char greenValue, unsigned char blueValue, int *error)
{
    unsigned int index = (redValue << 16) | (greenValue << 8) | blueValue;
 
    unsigned int redCluster[CHANNEL_CLUSTER_LENGTH];
    unsigned int greenCluster[CHANNEL_CLUSTER_LENGTH];
    unsigned int blueCluster[CHANNEL_CLUSTER_LENGTH];
 
    if (0 == this->colorCache[index]) {
 
        // red
 
        unsigned int redCode = Binary_writeCode(this->binary, redValue, error);
 
        if (*error) {
            return 0;
        }
 
        unsigned int redClusterStart = Graph_readLastTarget(this->graph, redCode, error);
 
        if (*error) {
            return 0;
        }
 
        if (0 == redClusterStart) {
 
            Graph_addCluster(this->graph, CHANNEL_CLUSTER_LENGTH, redCluster, error);
 
            if (*error) {
                return 0;
            }
 
            Graph_addEdge(this->graph, redCode, redCluster[0], error);
 
            if (*error) {
                return 0;
            }
 
        } else {
 
            Graph_readCluster(this->graph, redClusterStart, CHANNEL_CLUSTER_LENGTH, redCluster, error);
 
            if (*error) {
                return 0;
            }
        }
 
        unsigned int red = redCluster[0];
 
        // green
 
        unsigned int greenCode = Binary_writeCode(this->binary, greenValue, error);
 
        if (*error) {
            return 0;
        }
 
        unsigned int greenClusterStart = Graph_readLastTarget(this->graph, greenCode, error);
 
        if (*error) {
            return 0;
        }
 
        if (0 == greenClusterStart) {
 
            Graph_addCluster(this->graph, CHANNEL_CLUSTER_LENGTH, greenCluster, error);
 
            if (*error) {
                return 0;
            }
 
            Graph_addEdge(this->graph, greenCode, greenCluster[0], error);
 
            if (*error) {
                return 0;
            }
 
        } else {
 
            Graph_readCluster(this->graph, greenClusterStart, CHANNEL_CLUSTER_LENGTH, greenCluster, error);
 
            if (*error) {
                return 0;
            }
        }
 
        unsigned int green = greenCluster[1];
 
        // blue
 
        unsigned int blueCode = Binary_writeCode(this->binary, blueValue, error);
 
        if (*error) {
            return 0;
        }
 
        unsigned int blueClusterStart = Graph_readLastTarget(this->graph, blueCode, error);
 
        if (*error) {
            return 0;
        }
 
        if (0 == blueClusterStart) {
 
            Graph_addCluster(this->graph, CHANNEL_CLUSTER_LENGTH, blueCluster, error);
 
            if (*error) {
                return 0;
            }
 
            Graph_addEdge(this->graph, blueCode, blueCluster[0], error);
 
            if (*error) {
                return 0;
            }
 
        } else {
 
            Graph_readCluster(this->graph, blueClusterStart, CHANNEL_CLUSTER_LENGTH, blueCluster, error);
 
            if (*error) {
                return 0;
            }
        }
 
        unsigned int blue = blueCluster[2];
 
        // color
 
        unsigned int colorCluster[2];
 
        Graph_addCluster(this->graph, 2, colorCluster, error);
 
        if (*error) {
            return 0;
        }
 
        unsigned int color = colorCluster[0];
        unsigned int type = colorCluster[1];
 
        Graph_addEdge(this->graph, this->colorType, type, error);
 
        if (*error) {
            return 0;
        }
 
        Graph_addEdge(this->graph, red, color, error);
 
        if (*error) {
            return 0;
        }
 
        Graph_addEdge(this->graph, green, color, error);
 
        if (*error) {
            return 0;
        }
 
        Graph_addEdge(this->graph, blue, color, error);
 
        if (*error) {
            return 0;
        }
 
        this->colorCache[index] = color;
    }
 
    return this->colorCache[index];
 
    return 0;
}
 
void Colors_readColor(const struct Colors *this, unsigned int color, unsigned char *redValue, unsigned char *greenValue, unsigned char *blueValue, int *error)
{
    unsigned int colorCluster[COLOR_CLUSTER_LENGTH] = { 0, 0 };
 
    Graph_readCluster(this->graph, color, COLOR_CLUSTER_LENGTH, colorCluster, error);
 
    if (*error) {
        return;
    }
 
    if (0 == colorCluster[0] && 0 == colorCluster[1]) {
        *error = ERROR_NOT_A_COLOR;
        return;
    }
 
    unsigned int colorType = Graph_readLastSource(this->graph, colorCluster[1], error);
 
    if (colorType != this->colorType) {
        *error = ERROR_NOT_A_COLOR;
        return;
    }
 
    unsigned int colorSources[CHANNEL_SOURCES_LENGTH] = { 0, 0, 0 };
 
    Graph_readSources(this->graph, color, CHANNEL_SOURCES_LENGTH, colorSources, error);
 
    if (*error) {
        return;
    }
 
    // red
 
    unsigned int redCluster[CHANNEL_CLUSTER_LENGTH] = { 0, 0, 0};
 
    Graph_readCluster(this->graph, colorSources[2], CHANNEL_CLUSTER_LENGTH, redCluster, error);
 
    if (*error) {
        return;
    }
 
    unsigned int redCode = Graph_readLastSource(this->graph, redCluster[0], error);
 
    if (*error) {
        return;
    }
 
    *redValue = Binary_readCode(this->binary, redCode, error);
 
    if (*error) {
        return;
    }
 
    // green
 
    unsigned int greenCluster[CHANNEL_CLUSTER_LENGTH] = { 0, 0, 0};
 
    Graph_readCluster(this->graph, colorSources[1], CHANNEL_CLUSTER_LENGTH, greenCluster, error);
 
    if (*error) {
        return;
    }
 
    unsigned int greenCode = Graph_readLastSource(this->graph, greenCluster[2], error);
 
    if (*error) {
        return;
    }
 
    *greenValue = Binary_readCode(this->binary, greenCode, error);
 
    if (*error) {
        return;
    }
 
    // blue
 
    unsigned int blueCluster[CHANNEL_CLUSTER_LENGTH] = { 0, 0, 0};
    
    Graph_readCluster(this->graph, colorSources[0], CHANNEL_CLUSTER_LENGTH, blueCluster, error);
 
    if (*error) {
        return;
    }
 
    unsigned int blueCode = Graph_readLastSource(this->graph, blueCluster[1], error);
 
    if (*error) {
        return;
    }
 
    *blueValue = Binary_readCode(this->binary, blueCode, error);
}