std::pair<int, Quad> Decode::operator()(const std::vector<unsigned char> &bits, const Quad &corners) { auto result = doDecode(bits, corners); #ifdef HAS_INVERTED_TAGS if (result.first == INVALID_TAG) { //flip the bits, in case this tag is inverted std::vector<unsigned char> flippedBits(bits.size()); std::transform(bits.begin(), bits.end(), flippedBits.begin(), [](const unsigned char& c) { return 1 - c; }); result = doDecode(flippedBits, corners); } #endif return result; }
static jobject nativeDecodeByteArray( JNIEnv* env, jclass clazz, jbyteArray array, jint offset, jint length, jobject bitmapOptions, jfloat scale, jbyteArray inTempStorage) { // get image into decoded heap jbyte* data = env->GetByteArrayElements(array, nullptr); if (env->ExceptionCheck() == JNI_TRUE) { env->ReleaseByteArrayElements(inTempStorage, data, JNI_ABORT); RETURN_NULL_IF_EXCEPTION(env); } if (data == nullptr || offset + length > env->GetArrayLength(array)) { env->ReleaseByteArrayElements(array, data, JNI_ABORT); RETURN_NULL_IF_EXCEPTION(env); } jobject bitmap = doDecode(env, reinterpret_cast<uint8_t*>(data) + offset, length, bitmapOptions, scale); env->ReleaseByteArrayElements(array, data, JNI_ABORT); RETURN_NULL_IF_EXCEPTION(env); return bitmap; }
BitmapGlue* BitmapFactoryGlue::decodeByteArray(const NativeArray<uint8_t>& data, int offset, int length, Options& options) { /* If optionsShareable() we could decide to just wrap the java array and share it, but that means adding a globalref to the java array object and managing its lifetime. For now we just always copy the array's data if optionsPurgeable(), unless we're just decoding bounds. */ bool purgeable = options.isPurgeable && !options.justDecodeBounds; SkStream* stream = new SkMemoryStream(data.ptr(offset,length), length, purgeable); SkAutoUnref aur(stream); return doDecode(stream, options, purgeable); }
void calculateFitness(struct Chromosome *pop){ int calcPath[2*(1+GENETIC_PURSUERS+GENETIC_STEPS*GENETIC_PURSUERS)]; // Temporary variable for path calcPath[0]=GENETIC_PURSUERS; // Number of pursuers calcPath[1]=GENETIC_STEPS; // Number of steps doDecode(&(*pop), calcPath); // Decode allele to positions int temp = calculateStates(calcPath); // Calculate states (*pop).chrSteps = temp; // Write number of steps to individual if(temp>=0) (*pop).inS4 = 0; // If number of steps was positive, no nodes were in state 4 else (*pop).inS4 = getS4(); // Write number of nodes in state 4 //(*pop).fitnessScore = 1000/(1+(*pop).inS4+abs((*pop).chrSteps)); // Set fitness to 1000/(1+S4+steps), 1000 to scale fitness, 1+ to avoid division by 0. (*pop).fitnessScore = (ROWS*COLS+GENETIC_STEPS-(*pop).inS4-abs((*pop).chrSteps)); // Better fitness function? Nr of nodes in S123 + nr of steps not used. }
static jobject nativeDecodeStream( JNIEnv* env, jclass clazz, jobject is, jobject bitmapOptions, jfloat scale, jbyteArray inTempStorage) { auto encoded_image = readStreamFully(env, is, inTempStorage); if (!encoded_image.empty()) { return doDecode(env, encoded_image.data(), encoded_image.size(), bitmapOptions, scale); } return {}; }
BitmapGlue* BitmapFactoryGlue::nativeDecodeAsset(Asset& asset, SkIRect padding, Options& options) { SkStream* stream; bool forcePurgeable = options.isPurgeable; if (forcePurgeable) { // if we could "ref/reopen" the asset, we may not need to copy it here // and we could assume optionsShareable, since assets are always RO stream = copyAssetToStream(asset); if (NULL == stream) { return NULL; } } else { // since we know we'll be done with the asset when we return, we can // just use a simple wrapper stream = new AssetStreamAdaptor(asset); } SkAutoUnref aur(stream); return doDecode(stream, options, true, forcePurgeable); }
int main (int argc, char **argv) { int retval = 0; /* 0 - test succeeded. -1 - test failed */ SECStatus rv; PLOptState *optstate; char *program_name; char *input_file = NULL; /* read encrypted data from here (or create) */ char *output_file = NULL; /* write new encrypted data here */ char *log_file = NULL; /* write new encrypted data here */ FILE *inFile = stdin; FILE *outFile = stdout; FILE *logFile = NULL; PLOptStatus optstatus; secuPWData pwdata = { PW_NONE, NULL }; program_name = PL_strrchr(argv[0], '/'); program_name = program_name ? (program_name + 1) : argv[0]; optstate = PL_CreateOptState (argc, argv, "Hd:f:i:o:l:p:?"); if (optstate == NULL) { SECU_PrintError (program_name, "PL_CreateOptState failed"); return 1; } while ((optstatus = PL_GetNextOpt(optstate)) == PL_OPT_OK) { switch (optstate->option) { case '?': short_usage (program_name); return 1; case 'H': long_usage (program_name); return 1; case 'd': SECU_ConfigDirectory(optstate->value); break; case 'i': input_file = PL_strdup(optstate->value); break; case 'o': output_file = PL_strdup(optstate->value); break; case 'l': log_file = PL_strdup(optstate->value); break; case 'f': pwdata.source = PW_FROMFILE; pwdata.data = PL_strdup(optstate->value); break; case 'p': pwdata.source = PW_PLAINTEXT; pwdata.data = PL_strdup(optstate->value); break; } } PL_DestroyOptState(optstate); if (optstatus == PL_OPT_BAD) { short_usage (program_name); return 1; } if (input_file) { inFile = fopen(input_file,"r"); if (inFile == NULL) { perror(input_file); return 1; } PR_Free(input_file); } if (output_file) { outFile = fopen(output_file,"w+"); if (outFile == NULL) { perror(output_file); return 1; } PR_Free(output_file); } if (log_file) { if (log_file[0] == '-') logFile = stderr; else logFile = fopen(log_file,"w+"); if (logFile == NULL) { perror(log_file); return 1; } PR_Free(log_file); } /* * Initialize the Security libraries. */ PK11_SetPasswordFunc(SECU_GetModulePassword); rv = NSS_Init(SECU_ConfigDirectory(NULL)); if (rv != SECSuccess) { SECU_PrintError (program_name, "NSS_Init failed"); retval = 1; goto prdone; } /* Get the encrypted result, either from the input file * or from encrypting the plaintext value */ while (fgets(dataString, sizeof dataString, inFile)) { unsigned char c = dataString[0]; if (c == 'M' && isBase64(dataString)) { doDecrypt(dataString, outFile, logFile, &pwdata); } else if (c == '~' && isBase64(dataString + 1)) { doDecode(dataString, outFile, logFile); } else { fputs(dataString, outFile); } } if (pwdata.data) PR_Free(pwdata.data); fclose(outFile); fclose(inFile); if (logFile && logFile != stderr) { fclose(logFile); } if (NSS_Shutdown() != SECSuccess) { SECU_PrintError (program_name, "NSS_Shutdown failed"); exit(1); } prdone: PR_Cleanup (); return retval; }
void MSFTime::stateChange() // interrupt routine called on every state change { byte val = digitalRead(mInputPin); if( val == oldVal ) return; oldVal = val; long millisNow = millis(); if( mLedPin != 255 ) digitalWrite(mLedPin, val); // see here: // http://www.pvelectronics.co.uk/rftime/msf/MSF_Time_Date_Code.pdf // for an explanation of the format // Carrier goes off for 100, 200, 300, or 500 mS during every second // Our input is inverted by our receiver, so val != 0 when carrier is off if (val != 0) // carrier is off, start timing { if( millisNow - mOnStartMillis < PULSE_IGNORE_WIDTH) { // ignore this transition plus the previous one #ifdef EXTRA_DEBUG Serial.print("Ignoring on pulse len "); Serial.println(millisNow - mOnStartMillis); #endif mOnStartMillis = mPrevOnStartMillis; return; } mPrevOffStartMillis = mOffStartMillis; mOffStartMillis = millisNow; mOnWidth = mOffStartMillis - mOnStartMillis; return; } if( millisNow - mOffStartMillis < PULSE_IGNORE_WIDTH) { #ifdef EXTRA_DEBUG Serial.print("Ignoring off pulse len "); Serial.println(millisNow - mOffStartMillis); #endif // ignore this transition plus the previous one mOffStartMillis = mPrevOffStartMillis; return; } mPrevOnStartMillis = mOnStartMillis; mOnStartMillis = millisNow; long offWidth = millisNow - mOffStartMillis - PULSE_OFF_OFFSET; /* check the width of the off-pulse; according to the specifications, a * pulse must be 0.1 or 0.2 or 0.3 or 0.5 seconds */ boolean is500 = abs(offWidth-500) < PULSE_MARGIN; boolean is300 = abs(offWidth-300) < PULSE_MARGIN; boolean is200 = abs(offWidth-200) < PULSE_MARGIN; boolean is100 = abs(offWidth-100) < PULSE_MARGIN; long onWidth = mOnWidth; boolean onWas100 = (onWidth > 5) && (onWidth < 200); boolean onWasNormal = (onWidth > 400) && (onWidth < (900 + PULSE_MARGIN)); #ifdef EXTRA_DEBUG Serial.print("Sum "); Serial.print(offWidth + onWidth); Serial.print(" offWidth "); Serial.print(offWidth); Serial.print(" onWidth "); Serial.print(onWidth); Serial.print(" mBitIndex "); Serial.println((int)mBitIndex); #endif if( (onWasNormal || onWas100) && (is100 || is200 || is300 || is500 )) { mGoodPulses++; } else { #ifdef EXTRA_DEBUG Serial.println("Bad pulse!!!!!! "); #endif mGoodPulses = 0; } /* Cases: a 500mS carrier-off marks the start of a minute a 300mS carrier-off means bits 1 1 a 200mS carrier-off means bits 1 0 a 100mS carrier-off followed by a 900mS carrier-on means bits 0 0 a 100mS carrier-off followed by a 100mS carrier-on followed by a 100mS carrier-off means bits 0 1 */ if( is500 ) // minute marker { if( mIsReading ) doDecode(); mIsReading = true; // and get ready to read the next minute's worth mBitIndex = 1; // the NPL docs number bits from 1, so we will too } else if( mIsReading ) { if( mBitIndex < 60 && onWasNormal && (is100 || is200 || is300 )) // we got a sensible pair of bits, 00 or 01 or 11 { if( is100 ) { setBit( mABits, mBitIndex, 0 ); setBit( mBBits, mBitIndex++, 0 ); } if( is200 ) { setBit( mABits, mBitIndex, 1 ); setBit( mBBits, mBitIndex++, 0 ); } if( is300 ) { setBit( mABits, mBitIndex, 1 ); setBit( mBBits, mBitIndex++, 1 ); } #ifdef EXTRA_DEBUG if( getBit( mABits, mBitIndex - 1 )) Serial.println(" A = 1"); else Serial.println(" A = 0"); if( getBit( mBBits, mBitIndex - 1 )) Serial.println(" B = 1"); else Serial.println(" B = 0"); #endif } else if( mBitIndex < 60 && onWas100 && is100 && mBitIndex > 0 ) // tricky - we got a second bit for the preceding pair { setBit( mBBits, mBitIndex - 1, 1 ); #ifdef EXTRA_DEBUG if( getBit( mBBits, mBitIndex - 1 )) Serial.println(" B = 1"); else Serial.println(" B = 0"); #endif } else // bad pulse, give up { #ifdef DEBUG if( mIsReading || ! (is100 || is200 || is300 || is500)) { Serial.println("Bad pulse len"); Serial.print(" offWidth "); Serial.println(offWidth); Serial.print(" onWidth "); Serial.println(onWidth); Serial.print(" mBitIndex "); Serial.println((int)mBitIndex); } #endif mIsReading = false; mBitIndex = 0; } } }
/*** Algorithm ***/ void genAlg(int *solution) { // Main call function for Genetic Algorithm int currentGeneration=0, currentPopulation=0; int isSolved = 0; int k,i,j; int isChanged = 1; for(;GENETIC_POPULATION_SIZE<GENETIC_POPULATION_MAX_SIZE;GENETIC_POPULATION_SIZE+=GENETIC_INCREMENT_POPULATION){ for(i = GENETIC_POPULATION_SIZE; i < GENETIC_POPULATION_SIZE+GENETIC_INCREMENT_POPULATION; i++){ // Reset all genes. for(j = 0; j < GENETIC_PURSUERS; j++) for(k=0;k<GENETIC_STEPS;k++) Population[i].gene[j].allele[k] = 4; Population[i].inS4=999; // Reset fitness value (S4), just set to high value Population[i].chrSteps=999; // Reset fitness value (steps), set to high value Population[i].fitnessScore = 1; // Low value = bad solution, must be positive for(j = 0; j < GENETIC_PURSUERS; j++) for(k = 0; k < 2; k++) Population[i].gene[j].start[k] = Population[0].gene[j].start[k]; int GeneNr=0; for(GeneNr = 0; GeneNr < GENETIC_PURSUERS; GeneNr++){ // For each Gene getRandom(&(Population[i].gene[GeneNr]),0); // Generate a random step sequence } } if(isChanged == 1){ i = 0; isChanged = 0; } else{ i = GENETIC_POPULATION_SIZE; } for(; i < GENETIC_POPULATION_SIZE+GENETIC_INCREMENT_POPULATION; i++){ // Calculate fitness for population calculateFitness(&Population[i]); if(Population[i].inS4 == 0){ isSolved = 1; if(Population[i].chrSteps < GENETIC_STEPS){ isChanged = 1; GENETIC_STEPS = Population[i].chrSteps; } } } if(isSolved==1 && GENETIC_POPULATION_SIZE>GENETIC_MIN_POP_SIZE) break; } printf("genAlg\n"); printf("**** Genetic Algorithm info ****\n"); printf("Population size:\t%d\n", GENETIC_POPULATION_SIZE); printf("Pursuers:\t\t%d\n", GENETIC_PURSUERS); printf("Maximum steps:\t\t%d\n", GENETIC_STEPS); printf("Maximum generations:\t%d\n", GENETIC_GENERATIONS); printf("Convergence %%:\t\t%d\n", abs(GENETIC_CONVERGENCE_PERCENT*100)); printf("Mutation %%:\t\t%d\n", abs(GENETIC_MUTATION_PROBABILITY*100)); sortPopulation(Population, GENETIC_POPULATION_SIZE); // Sort the population after fitness for(currentGeneration = 0; currentGeneration < GENETIC_GENERATIONS; currentGeneration++){ /*** New generation ***/ /* calculateFitness(&Population[0]); printStates(); printf("Generation %d\n", currentGeneration); */ addToNewPopulation(Population[0]); // Elite selection addToNewPopulation(Population[1]); // Elite selection while(NewPopLocation < GENETIC_POPULATION_SIZE) doReproduce(); // Reproduction sortPopulation(New_Population, GENETIC_POPULATION_SIZE); // Sort the new population after fitness /*** Swap populations ***/ int i; for(i = 0; i < GENETIC_POPULATION_SIZE;i++) Population[i] = New_Population[i]; // Overwrite old population with new memcpy(Population, New_Population, sizeof New_Population); /* if(currentGeneration%1==0){ printf("Best Fitness: %f, States: %d, steps: %d\n", Population[0].fitnessScore, Population[0].inS4, Population[0].chrSteps); printf("Compare Fitness (%d): %f, States: %d, steps: %d\n", abs(GENETIC_POPULATION_SIZE*GENETIC_CONVERGENCE_PERCENT), Population[abs(GENETIC_POPULATION_SIZE*GENETIC_CONVERGENCE_PERCENT)].fitnessScore, Population[abs(GENETIC_POPULATION_SIZE*GENETIC_CONVERGENCE_PERCENT)].inS4, Population[abs(GENETIC_POPULATION_SIZE*GENETIC_CONVERGENCE_PERCENT)].chrSteps); printf("Worst Fitness (%d): %f, States: %d, steps: %d\n", GENETIC_POPULATION_SIZE, Population[GENETIC_POPULATION_SIZE-1].fitnessScore, Population[GENETIC_POPULATION_SIZE-1].inS4, Population[GENETIC_POPULATION_SIZE-1].chrSteps); } */ if(Population[0].inS4 == 0 && Population[abs(GENETIC_POPULATION_SIZE*GENETIC_CONVERGENCE_PERCENT)].inS4 == 0) // If a complete solution has been found, check if convergence level is reached if((Population[0].chrSteps==Population[abs(GENETIC_POPULATION_SIZE*GENETIC_CONVERGENCE_PERCENT)].chrSteps)) // If 90% of the population has the same number of steps, no need to continue to do more generations. if(Population[0].fitnessScore==Population[abs(GENETIC_POPULATION_SIZE*GENETIC_CONVERGENCE_PERCENT)].fitnessScore) // Redundant check, check fitness score break; NewPopLocation=0; } printf("%d generations used.\n", currentGeneration); printf("Best Fitness: %f, States: %d, steps: %d\n", Population[0].fitnessScore, Population[0].inS4, Population[0].chrSteps); printf("Compare Fitness: %f, States: %d, steps: %d\n", Population[abs(GENETIC_POPULATION_SIZE*GENETIC_CONVERGENCE_PERCENT)].fitnessScore, Population[abs(GENETIC_POPULATION_SIZE*GENETIC_CONVERGENCE_PERCENT)].inS4, Population[abs(GENETIC_POPULATION_SIZE*GENETIC_CONVERGENCE_PERCENT)].chrSteps); printf("Worst Fitness: %f, States: %d, steps: %d\n", Population[GENETIC_POPULATION_SIZE-1].fitnessScore, Population[GENETIC_POPULATION_SIZE-1].inS4, Population[GENETIC_POPULATION_SIZE-1].chrSteps); solution[0]=GENETIC_PURSUERS; // Write number of pursuers to solution solution[1]=GENETIC_STEPS; // Write maximum number of steps to solution if(Population[0].chrSteps<=MAX_SIZE_SOLUTION){ doDecode(&Population[0], solution); // Decode solution to positions solution[1]=calculateStates(solution); // Calculate states, and update steps to minimum } else solution[1]=Population[0].chrSteps; // If the solution was to long, or not found, no need to return path /*** Free allocated memory ***/ free(Population); free(New_Population); /*** Free memory for NodeMatrix ***/ for(i = 0; i < ROWS;i++) free(NodeMatrix[i]); free(NodeMatrix); return; }