MQSOSubSwarm::MQSOSubSwarm(int size, bool flag):Swarm<CodeVReal,MQSOParticle>(size,flag),m_Nplus(5),m_Nq(5),\ m_N(5),m_Q(pow(1./4.9,1./0.6)),m_Rcloud(1.0){ assignType(); m_swarmType=2; }
// --- Properties ---------------------------------------------------------- // void AmberAtomTyper::setMolecule(const chemkit::Molecule *molecule) { chemkit::AtomTyper::setMolecule(molecule); m_types.resize(molecule->atomCount()); for(size_t i = 0; i < molecule->size(); i++) { m_types[i] = assignType(molecule->atom(i)); } }
/** * @brief Parser::parse Parses the sentence and creates the trees * @return the trees */ STvector Parser::parse(){ SyntaxTree S(new TNpair(GtSpair(SENTENCE,SyntaxWord()))); //At the beginning, CURRENT is at the true root std::size_t cutoff = 0; while(recDescent(S,cutoff)){ //RecDescends based on the CURRENT pointer in the tree _valid.insert(_valid.end(),S); if(!findFirstIncomplete(S)) //Sets the CURRENT to the first slowest subtree that has more defs to explore break; //If it cannot find any more subtrees with more defs to explore, then stop cutoff = S.leavesBefore(); removePartial(S); } //As long as recdescent is able to continue making trees for(std::size_t i = 0; i < _valid.size(); ++i){ _valid[i].shiftToRoot(); assignType(_valid[i]); attachWords(_valid[i]); assignHeadWords(_valid[i]); assignObjects(_valid[i]); } removeTrees(); return _valid; }
int main (int argc, char **argv) { struct CCDdev device = {"/dev/ccda"}; struct CCDexp exposure = {&device}; unsigned short *pixelRow, *end; int overage; unsigned avgPixel = 0; char *outFn; FILE *outFile; const static struct option options[] = { {"autoexpose", 2, NULL, 'a'}, {"binning", 1, NULL, 'b'}, {"bin", 1, NULL, 'b'}, {"offset", 1, NULL, 'o'}, {"origin", 1, NULL, 'o'}, {"size", 1, NULL, 's'}, {"dark", 0, NULL, 'D'}, // {"depth", 1, NULL, 'd'}, {"nowipe", 0, NULL, 'w'}, {"noclear", 0, NULL, 'c'}, {"noaccumulation", 0, NULL, 'A'}, {"tdi", 0, NULL, 't'}, {"TDI", 0, NULL, 't'}, {"tiff", 2, NULL, 'T'}, {"TIFF", 2, NULL, 'T'}, {"FITS", 0, NULL, 'F'}, {"fits", 0, NULL, 'F'}, {"JPEG", 0, NULL, 'J'}, {"jpeg", 0, NULL, 'J'}, {"camera", 1, NULL, 'n'}, {"debug", 2, NULL, 'S'}, {"help", 0, NULL, 'h'}, {NULL} }; progName = basename (argv[0]); if (write (progressFD, "", 0)) progressFD=fileno(stdout); for (;;) { int optc = getopt_long_only (argc, argv, "", options, 0); switch(optc) { case -1: goto gotAllOpts; case 'a': //auto exposure exposureSecs = 5*60; //default to 5 minute max exposure time if (optarg) { char *terminator = optarg; if (*optarg != ',') terminator=parseDuration (optarg, &exposureSecs); switch (*terminator) { case ',': switch(*(terminator=parseInt (terminator+1, &maxAutoSignal))) { case ',': if (*parseInt(terminator+1, &adcBias)) syntaxErr("Junk text after min A/D counts!"); case '\0': break; default: syntaxErr("Junk text after autoexposure max A/D count target!"); } case '\0': break; default: syntaxErr ("Junk text after autoexposure max duration!"); } if (exposureSecs < 0.002) syntaxErr ("autoexposure limit must be > 2ms"); } exposureSecs = -exposureSecs; break; case 'b': //XY binning parseXYoptArg (&binX, &binY); if (!validBin(binX) || !validBin(binY)) syntaxErr ("Binning factors must be between 1 and 4!"); break; case 'o': //origin offset parseXYoptArg (&offsetX, &offsetY); if (offsetX < 0 || offsetY < 0) syntaxErr ("Negative origin offset specified!"); break; case 's': //image size parseXYoptArg (&sizeX, &sizeY); if (sizeX < 0 || sizeY < 0) syntaxErr ("Negative image size specified!"); break; case 'd': //depth if (*parseInt (optarg, &CCDdepth)) syntaxErr ("invalid text after depth option"); if (CCDdepth <= 0) syntaxErr ("Negative # of depth bits specified"); break; case 'S': //display debuging status info debug = optarg ? atoi(optarg) : 1; break; case 'w': //suppress CCD wipe exposure.flags |= CCD_EXP_FLAGS_NOWIPE_FRAME; break; case 'c': //suppress image clear exposure.flags |= CCD_EXP_FLAGS_NOCLEAR_FRAME; break; case 't': //time delay integration exposure.flags |= CCD_EXP_FLAGS_TDI; break; case 'A': //no binning accumulation exposure.flags |= CCD_EXP_FLAGS_NOBIN_ACCUM; break; case 'D': //dard frame exposure.flags |= CCD_EXP_FLAGS_NOOPEN_SHUTTER; break; case 'n': //camera device file device.filename[NAME_STRING_LENGTH]='\0'; strncpy (device.filename, optarg, NAME_STRING_LENGTH-1); break; case 'T': //generate TIFF file assignType(TIFFfile); if (optarg && toupper(*optarg)=='D') setenv ("TIFF_COMPRESSION", "32946", 1); break; case 'F': //generate FITS file assignType(FITSfile); break; case 'J': //generate JPEG file assignType(JPEGfile); break; case 'h': usage(); return 0; default: syntaxErr("invalid option: %s", argv[optind]); } } gotAllOpts: //on to arguments (exposure time and output file name) if (exposureSecs == 0.0) { if (!argv[optind]) syntaxErr ("Missing Exposure Time"); if (*parseDuration (argv[optind], &exposureSecs)) syntaxErr ("Junk text after exposure duration"); if (exposureSecs < 0.001) syntaxErr ("Exposure duration must be >= 0.001 seconds"); ++optind; } if (!CCDconnect (&device)) { fprintf (stderr, "Cannot open camera device: %s\n", device.filename); return 1; } printf ("%s: %dx%d pixel %d-bit CCD camera\n", device.camera, device.width, device.height, device.depth); outFn = argv[optind]; if (outFn) { char *lastDot; outFile = fopen (outFn, "w"); if (!outFile) { perror(outFn); return errno; } if (outputFileType == unspecifiedFile) { lastDot = strrchr (outFn, '.'); if (lastDot) switch (toupper(lastDot[1])) { case 'J': outputFileType = JPEGfile; break; case 'T': outputFileType = TIFFfile; break; case 'F': outputFileType = FITSfile; break; } } }else //trying to write image to stdout syntaxErr ("Missing output image filename!"); exposure.width = sizeX ? sizeX : device.width; exposure.height = sizeY ? sizeY : device.height; exposure.xoffset = offsetX; exposure.yoffset = offsetY; overage = device.width - exposure.width - offsetX; if (overage < 0) exposure.width += overage; overage = device.height - exposure.height - offsetY; if (overage < 0) exposure.height += overage; exposure.xbin = binX; exposure.ybin = binY; exposure.dacBits = CCDdepth ? CCDdepth : device.dacBits; if (exposure.dacBits < 8 || exposure.dacBits > 16) syntaxErr ("Pixel depth of %d bits is not currently supported!\n", exposure.dacBits); if (exposureSecs < 0.0) { exposureSecs = -exposureSecs; if (debug) printf( "Calibrating <= %g second exposure between %d and %d A/D counts...\n", exposureSecs, maxAutoSignal, adcBias); exposure.msec = exposureSecs * 1000.0 + 0.5; if (optimizeExposure (&exposure)) { fprintf (stderr, "Autoexposure calibration failed!\n"); return 6; } }else exposure.msec = exposureSecs * 1000.0 + 0.5; exposureSecs = (double)exposure.msec / 1000.0; printf ("Exposing %dx%d pixel %d-bit image for %g seconds\n", exposure.width/binX, exposure.height/binY, exposure.dacBits, exposureSecs); expose (&exposure); /* Write out the image in the specified format */ switch (outputFileType) { case unspecifiedFile: outputFileType = TIFFfile; //default to TIFF case TIFFfile: { TIFF *tif = TIFFFdOpen (fileno(outFile), outFn, "w"); if (!tif || saveTIFF (tif, &exposure)) imageWrtFailed(); TIFFClose(tif); } break; case FITSfile: if (saveFITS (fileno(outFile), &exposure)) imageWrtFailed(); break; default: syntaxErr("Unsupported image file type: %s",fileTypeName[outputFileType]); } printf ("%s: %s Upload Complete\n", outFn, fileTypeName[outputFileType]); return 0; }
/************************************************************************************************** * Analyze the terrain and assign the proper type **************************************************************************************************/ void TerrainAnalyzer::analyze(SmurfPolygon*** terrain, int w, int h, float maxHeight, float minHeight) { // Iterate through the terrain and analyze each individual terrain piece of terrain for(int i = 0; i < h; i++) { for(int j = 0; j < w; j+=2) { // Clear the probabilities clearProbabilities(); // Choose the a piece of terrain and analyze it //********************************************************************************************** // Analyze slope analyzeSlope(terrain[i][j]); // Analyze height analyzeHeight(terrain[i][j], maxHeight, minHeight); /* Analyze adjacent terrains * Even * i-1: j-1, j, j+1, j+2, j+3 * i: j-2, j-1 * Odd * i-1: j, j+1, j+2 * i: j-2, j-1 */ int adjacentAnalyzed = 0; if(i % 2 == 0) { // Even // case: i - 1 if(i - 1 >= 0) { if(j - 1 >= 0) { analyzeAdjacent(terrain[i][j], terrain[i-1][j-1]); adjacentAnalyzed++; } analyzeAdjacent(terrain[i][j], terrain[i-1][j]); adjacentAnalyzed++; if(j + 1 < w) { analyzeAdjacent(terrain[i][j], terrain[i-1][j+1]); adjacentAnalyzed++; } if(j + 2 < w) { analyzeAdjacent(terrain[i][j], terrain[i-1][j+2]); adjacentAnalyzed++; } if(j + 3 < w) { analyzeAdjacent(terrain[i][j], terrain[i-1][j+3]); adjacentAnalyzed++; } } // case: i if(j - 2 >= 0) { analyzeAdjacent(terrain[i][j], terrain[i][j-2]); adjacentAnalyzed++; } if(j - 1 >= 0) { analyzeAdjacent(terrain[i][j], terrain[i][j-1]); adjacentAnalyzed++; } } else { // Odd // case: i - 1 if(i - 1 >= 0) { analyzeAdjacent(terrain[i][j], terrain[i-1][j]); adjacentAnalyzed++; if(j + 1 < w) { analyzeAdjacent(terrain[i][j], terrain[i-1][j+1]); adjacentAnalyzed++; } if(j + 2 < w) { analyzeAdjacent(terrain[i][j], terrain[i-1][j+2]); adjacentAnalyzed++; } } // case: i if(j - 2 >= 0) { analyzeAdjacent(terrain[i][j], terrain[i][j-2]); adjacentAnalyzed++; } if(j - 1 >= 0) { analyzeAdjacent(terrain[i][j], terrain[i][j-1]); adjacentAnalyzed++; } } if(adjacentAnalyzed == 0) adjacentAnalyzed = 1; // Find the average probability of the adjacent values for(int k = 0; k < 6; k++) { // Edge case testing. This is to prevent a band of the most probable substance at the seeding // corner, essentially this causes the entire first row of values to act as a seed rather than the first value. if(i == 0) terrainProbabilities[k][3] = 0.1f; else terrainProbabilities[k][3] = terrainProbabilities[k][3] / (float)adjacentAnalyzed; } // Use naive bayes for final analysis of probabilities naiveBayes(); // assign terrain type assignType(terrain[i][j]); assignType(terrain[i][j+1]); } } }