string outArvore(vector <Symbol> symbols, string encoded, string *code)
{
string outBin = "", c1 = "", c2 = "";
*code = symbols.front().getCode();
short unsigned index = 0;
while (index < symbols.size() - 1)
{
c1 = symbols[index].getCode(); // Codigo do elemento mais significativo
c2 = symbols[index+1].getCode(); // Codigo do segundo elemento mais significativo
index++;
int i = 0;
while (c1[i] == c2[i]) // Enquanto os bits de dois simbolos vizinhos forem iguais
i++;
c2.erase(0,i); // Remova os i bits iguais entre os dois simbolos
(*code) += c2; // Adicione o resto ao codigo da arvore
}
*code += '1'; // Adiciona-se o bit 1 para finalizar a representação da arvore
outBin = *code;
// code.clear();
c1.clear();
c2.clear();
for (short i = 0; i < symbols.size(); i++)
{
c1 = intToBin((unsigned char) symbols[i].getCharacter()); // Transforma o codigo ASCII do simbolo em binario
fill(&c1, 8-c1.size()); // Aumenta a quantidade de bits do codigo para um byte
outBin += c1; // Adiciona-se o codigo de cada simbolo
}
c1.clear();
outBin += encoded; // Adiciona-se a mensagem codificada em Shannon-Fano
encoded.clear();
index = 0;
while (index + 8 < outBin.size())
{
c1.assign(outBin, index, 8); // Atribui a substring de text com tamanho 8 começando de j
outBin.erase(index,8);
c2 += (char) binToInt(c1); // Transforma a string binaria bite em um numero inteiro
}
c1.assign(outBin, index, 8);
c2 += (char) binToInt(c1);
c2 += (char) c1.size();
return c2;
}
void binIncrement_test() {
bin_int_t r = 1;
for (bin_int_t i = 0; i < BIN_BITS*BIN_BITS; ++i) {
bin b = binRandr(0, BIN_INT_MAX - 1);
r &= (binToInt(b) + 1) == binToInt(binIncrement(b));
}
processTestResults("binIncrement", r);
}
void binDecrement_test() {
bin_int_t r = 1;
for (bin_int_t i = 0; i < BIN_BITS*BIN_BITS; ++i) {
bin b = binRandr(1, BIN_INT_MAX);
bin_int_t bi = binToInt(b);
r &= (bin_int_t)(bi - 1) == binToInt(binDecrement(b));
}
processTestResults("binDecrement", r);
}
void binPow_test() {
bin_int_t r = 1;
for (bin_int_t i = 0; i < BIN_BITS*BIN_BITS; ++i) {
bin b1 = binNew(i);
bin b2 = binNew(sqrt(sqrt(BIN_BITS*BIN_BITS - i + 1) + 1));
bin_int_t bi1 = binToInt(b1);
bin_int_t bi2 = binToInt(b2);
r &= (bin_int_t)pow(bi1, bi2) == binToInt(binPow(b1, b2));
}
processTestResults("binPow", r);
}
void binModulus_test() {
bin_int_t r = 1;
for (bin_int_t i = 0; i < BIN_BITS*BIN_BITS; ++i) {
bin b1 = binNew(i);
bin_int_t bi1 = binToInt(b1);
bin b2 = binRand();
bin_int_t bi2 = binToInt(b2);
r &= (bi1 % bi2) == binToInt(binModulus(b1, b2));
}
processTestResults("binModulus", r);
}
void binDivide_test() {
bin_int_t r = 1;
for (bin_int_t i = 0; i < BIN_BITS*BIN_BITS; ++i) {
bin b1 = binRandr(1, BIN_INT_MAX);
bin_int_t bi1 = binToInt(b1);
bin b2 = binRandr(1, bi1);
bin_int_t bi2 = binToInt(b2);
r &= (bi1 / bi2) == binToInt(binDivide(b1, b2));
}
processTestResults("binDivide", r);
}
void binMultiply_test() {
bin_int_t r = 1;
for (bin_int_t i = 0; i < BIN_BITS*BIN_BITS; ++i) {
bin b1 = binRand();
bin_int_t bi1 = binToInt(b1);
bin b2 = binRandr(0, BIN_INT_MAX / bi1);
bin_int_t bi2 = binToInt(b2);
r &= (bin_int_t)(bi1 * bi2) == binToInt(binMultiply(b1, b2));
}
processTestResults("binMultiply", r);
}
void binAdd_test() {
bin_int_t r = 1;
for (bin_int_t i = 0; i < BIN_BITS*BIN_BITS; ++i) {
bin b1 = binRand();
bin_int_t bi1 = binToInt(b1);
bin b2 = binRandr(0, BIN_INT_MAX - bi1);
bin_int_t bi2 = binToInt(b2);
r &= (bi1 + bi2) == binToInt(binAdd(b1, b2));
}
processTestResults("binAdd", r);
}
void binSubtract_test() {
bin_int_t r = 1;
for (bin_int_t i = 0; i < BIN_BITS*BIN_BITS; ++i) {
bin b1 = binRand();
bin_int_t bi1 = binToInt(b1);
bin b2 = binRandr(0, bi1);
bin_int_t bi2 = binToInt(b2);
r &= (bi1 - bi2) == binToInt(binSubtract(b1, b2));
}
processTestResults("binSubtract", r);
}
void writeCompressedData(FILE* file)
{
FILE *backp = fopen("backp.txt","r");
unsigned char currentChar;
unsigned char binaryText[9];
unsigned char CharT;
int Char=0,count=0,i,binary[8];
while(fgets(binaryText,9,backp)!=NULL)
{
for(i=0;i<strlen(binaryText);++i) // CONVERTE A STRING PARA ARRAY DE INTEIROS
{
binary[i] = binaryText[i] - 48;
}
if(strlen(binaryText) < 8)//PREENCHE COM 0 CASO O BINARIO N TENHA TAMANHO 8
{
for(i= strlen(binaryText) ; i<8 ; ++i)
{
binary[i] = 0;
}
}
CharT = binToInt(binary);
fprintf(file,"%c",CharT);
}
fclose(backp);
}
std::vector<int> CGenetic::decode(const std::vector<int> &bits)
{
std::vector<int> directions;
// std::stringstream str;
for (int gene=0; gene<bits.size(); gene += m_iGeneLength)
{
std::vector<int> thisGene(bits.begin() + gene, bits.begin() + gene + m_iGeneLength);
directions.push_back(binToInt(thisGene));
// str << binToInt(thisGene) << ",";
}
// CCLOG(str.str().c_str());
return directions;
}
bool cwagmSegmentationEvaluation::chromosomeToPhenotype(
const chromosome& genotype,
functor::parameters& phenotype) const {
const parameters& par = getParameters();
cwagmSegmentation::parameters* phen =
dynamic_cast<cwagmSegmentation::parameters*>(&phenotype);
if (isNull(phen)) {
return false;
}
int pos=0;
int ires,theMin,theMax;
double dres;
// median kernel size
pos = binToInt(genotype,pos,bits::MedianKernel,
(par.minValues.medianParam.kernelSize-1)/2,
(par.maxValues.medianParam.kernelSize-1)/2,ires);
phen->medianParam.kernelSize = (ires*2+1);
// color splitter
pos = binToInt(genotype,pos,bits::ColorSplitter,0,7,ires);
if (par.minValues.colorSplitter == par.maxValues.colorSplitter) {
phen->colorSplitter = par.minValues.colorSplitter;
} else {
if (par.minValues.colorSplitter.find("XYZ") != std::string::npos){
theMin=1;
} else if (par.minValues.colorSplitter.find("xyY") != std::string::npos){
theMin=2;
} else if (par.minValues.colorSplitter.find("Luv") != std::string::npos){
theMin=3;
} else if (par.minValues.colorSplitter.find("rgI") != std::string::npos){
theMin=4;
} else if (par.minValues.colorSplitter.find("YUV") != std::string::npos){
theMin=5;
} else if (par.minValues.colorSplitter.find("YIQ") != std::string::npos){
theMin=6;
} else if (par.minValues.colorSplitter.find("OCP") != std::string::npos){
theMin=7;
} else { // (par.minValues.colorSplitter.find("RGB")!=std::string::npos)
theMin=0; // RGB
}
if (par.maxValues.colorSplitter.find("XYZ") != std::string::npos){
theMax=1;
} else if (par.maxValues.colorSplitter.find("xyY") != std::string::npos){
theMax=2;
} else if (par.maxValues.colorSplitter.find("Luv") != std::string::npos){
theMax=3;
} else if (par.maxValues.colorSplitter.find("rgI") != std::string::npos){
theMax=4;
} else if (par.maxValues.colorSplitter.find("YUV") != std::string::npos){
theMax=5;
} else if (par.maxValues.colorSplitter.find("YIQ") != std::string::npos){
theMax=6;
} else if (par.maxValues.colorSplitter.find("OCP") != std::string::npos){
theMax=7;
} else { // (par.maxValues.colorSplitter.find("RGB")!=std::string::npos)
theMax=0; // RGB
}
ires = max(theMin,min(theMax,ires));
switch (ires) {
case 0:
phen->colorSplitter = "lti::splitImageToRGB";
break;
case 1:
phen->colorSplitter = "lti::splitImageToXYZ";
break;
case 2:
phen->colorSplitter = "lti::splitImageToxyY";
break;
case 3:
phen->colorSplitter = "lti::splitImageToLuv";
break;
case 4:
phen->colorSplitter = "lti::splitImageTorgI";
break;
case 5:
phen->colorSplitter = "lti::splitImageToYUV";
break;
case 6:
phen->colorSplitter = "lti::splitImageToYIQ";
break;
case 7:
phen->colorSplitter = "lti::splitImageToOCP";
break;
default:
phen->colorSplitter = "lti::splitImageToXYZ";
break;
}
}
// gradient kernel type
pos = binToInt(genotype,pos,bits::GradientType,0,7,ires);
if (par.minValues.colorContrastParam.kernelType ==
par.maxValues.colorContrastParam.kernelType) {
phen->colorContrastParam.kernelType =
par.minValues.colorContrastParam.kernelType;
} else {
theMin = static_cast<int>(par.minValues.colorContrastParam.kernelType);
theMax = static_cast<int>(par.maxValues.colorContrastParam.kernelType);
minmax(theMin,theMax);
ires = max(theMin,min(theMax,ires));
phen->colorContrastParam.kernelType =
static_cast<gradientFunctor::parameters::eKernelType>(ires);
}
// gradient contrast format
pos = binToInt(genotype,pos,bits::ContrastFormat,0,3,ires);
if (par.minValues.colorContrastParam.contrastFormat ==
par.maxValues.colorContrastParam.contrastFormat) {
phen->colorContrastParam.contrastFormat =
par.minValues.colorContrastParam.contrastFormat;
} else {
theMin=static_cast<int>(par.minValues.colorContrastParam.contrastFormat);
theMax=static_cast<int>(par.maxValues.colorContrastParam.contrastFormat);
minmax(theMin,theMax);
ires = max(theMin,min(theMax,ires));
phen->colorContrastParam.contrastFormat =
static_cast<colorContrastGradient::parameters::eContrastFormat>(ires);
}
// watershed configuration
// neighborhood
pos = binToInt(genotype,pos,bits::WatershedNeighborhood,
(par.minValues.watershedParam.neighborhood8) ? 1 : 0,
(par.maxValues.watershedParam.neighborhood8) ? 1 : 0,
ires);
phen->watershedParam.neighborhood8 = (ires != 0);
// WatershedThreshold
pos = binToInt(genotype,pos,bits::WatershedThreshold,
par.minValues.watershedParam.threshold,
par.maxValues.watershedParam.threshold,ires);
phen->watershedParam.threshold = static_cast<ubyte>(ires);
// minProbForWatershedThreshold
pos = binToDouble(genotype,pos,bits::WatershedMinProbThreshold,
par.minValues.minProbForWatershedThreshold,
par.maxValues.minProbForWatershedThreshold,dres);
phen->minProbForWatershedThreshold = static_cast<float>(dres);
// harisRegionMergeParam.mergeThreshold
pos = binToDouble(genotype,pos,bits::WatershedHarisMerge,
par.minValues.harisRegionMergeParam.mergeThreshold,
par.maxValues.harisRegionMergeParam.mergeThreshold,dres);
phen->harisRegionMergeParam.mergeThreshold = static_cast<float>(dres);
// harisRegionMergeParam.mergeMode
pos = binToInt(genotype,pos,bits::WatershedHarisMergeMode,
static_cast<int>(par.minValues.harisRegionMergeParam.mergeMode),
static_cast<int>(par.maxValues.harisRegionMergeParam.mergeMode),
ires);
phen->harisRegionMergeParam.mergeMode =
static_cast<regionGraphColorHaris::parameters::eMergeMode>(ires);
// harisRegionMergeParam.minRegionNumber
pos = binToDouble(genotype,pos,bits::WatershedHarisMinNumRegions,
par.minValues.harisRegionMergeParam.minRegionNumber,
par.maxValues.harisRegionMergeParam.minRegionNumber,
dres);
phen->harisRegionMergeParam.minRegionNumber = iround(dres);
// check in debug modus that everything is there!
assert(pos == bits::total());
return true;
}
