virtual void output(Entity* entity, QIODevice& iodevice) const{ QStringList tokens= getCommentInternalText(BOOK_TAG).split(",",QString::SkipEmptyParts); QString title = tokens.takeFirst(); QString location=tokens.takeFirst(); QStringList pages = tokens; QString declPagesArray="var pages = ["; QString lastPage = pages.takeLast(); for(const QString& pageNumber: pages){ declPagesArray.append('"').append(pageNumber).append("\",\n"); } declPagesArray.append('"').append(lastPage).append("\"];\n"); qDebug() << declPagesArray << location; QFileInfo bookDir(outputSite,location); if (!bookDir.exists()){ return; } QFile outputJsFile(QFileInfo(QDir(bookDir.absolutePath()),"numero.js").absoluteFilePath()); if (!outputJsFile.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)){ return ; } outputJsFile.write(declPagesArray.toUtf8()); outputJsFile.write(readTemplate("://templates/numero.js").toUtf8()); QFile outputHtmlFile(QFileInfo(QDir(bookDir.absolutePath()),"numero.html").absoluteFilePath()); if (!outputHtmlFile.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)){ return ; } outputHtmlFile.write(readTemplate("://templates/numero.html").toUtf8()); QString anchor=QString("<a href=\"").append(location).append("numero.html#page/1/mode/2up\">").append(title).append("</a>"); iodevice.write(anchor.toUtf8()); }
void Task::setClosed(bool closed) { if (closed) { setStatus(readTemplate(*_templateName)->closedStatus()); } else { setStatus(defaultTemplate()->name()); } }
void Task::processTemplate() { Template* temp = readTemplate(*_templateName); std::vector<string> subtasks = temp->subTaskList(); int subId = 1; for (std::vector<string>::iterator iterSub = subtasks.begin(); iterSub != subtasks.end(); iterSub++) { string subtask = *iterSub; int posPar = subtask.find('('); int posFin = subtask.find(')'); string tempSub = subtask.substr(posPar + 1, posFin - posPar - 1); string subTaskName = subtask.substr(0, posPar); Task* sub = new Task(_project); std::stringstream ssId; ssId << *id() << "." << subId++; sub->setId(new string(ssId.str())); sub->setDuration(Duration(1, 0, 0)); sub->setEndDate(endDate()); sub->setShortDescription(new string(subTaskName)); sub->setStartDate(startDate()); sub->setStatus(status()); sub->setTemplateName(new string(tempSub)); _project->addTask(sub); if (errorOcurred()) { return; } sub->processTemplate(); } }
Task::Task(Project* project, const std::string taskDef) { qDebug("Task::Task(Project* project, std::string* taskDef)"); _project = project; _totalTime = 0; _logs = new vector<TaskLog*>(); hashmap* values = parseTextFormat(taskDef); _id = new std::string(READ_ELEMENT(values, "task-id")); qDebug("Loading task id: %s", _id->c_str()); _shortDescription = new std::string(READ_ELEMENT(values, "short-description")); _longDescription = new std::string(READ_ELEMENT(values, "long-description")); _duration = Duration(READ_ELEMENT(values, "duration").c_str()); _startDate = new DateTime(READ_ELEMENT(values, "startdate")); _endDate = new DateTime(READ_ELEMENT(values, "enddate")); _templateName = new string(READ_ELEMENT(values, "template-name")); _status = new string(READ_ELEMENT(values, "status")); Template* tpl = readTemplate(*_templateName); // Check the current template existance if (tpl == NULL) { qDebug("Warning: The task with id: %s contains an invalid template: %s", _id->c_str(), _templateName->c_str()); _templateName = defaultTemplate()->name(); _status = new string(*defaultTemplate()->statusList().begin()); } int red = randColor(); int green = randColor(); int blue = randColor(); _taskColor = QColor(red, green, blue); _parentTask = NULL; delete(values); qDebug("out Task::Task(Project* project, std::string* taskDef)"); }
bool Task::isClosed() const { Template* tpl = readTemplate(*this->templateName()); if (tpl != NULL) { return (tpl->closedStatus()->compare(*_status) == 0); } else { return false; } }
int main(int argc, char *argv[]) #endif { FILE *fp; int i, j; A_UINT8 *pData = (A_UINT8 *)&EepromData; AR6000_EEPROM *pEepStruct = (AR6000_EEPROM*)&EepromData; if ((NULL != argv[1]) && (NULL != argv[2]) && (NULL != argv[3])) { } else { printf("Usage: eepromBin2Txt.out <eeprom template> <input eeprom text> <output eeprom bin>\n"); return -1; } #if !defined(_USE_AS_API) // read template if (FALSE == readTemplate(argv[1])) { printf("Error reading template file %s \n", argv[1]); return -1; } else { _printf(".reading template file %s \n", argv[1]); } #endif // parse eeprom txt and fill the binary data. if (FALSE == parseEepromTxtFile(argv[2], (A_UINT8 *)&EepromData)) { printf("Error reading EEPROM text file %s \n", argv[2]); return -1; } //for (i = 0; i < 10; ++i) //{ // printf("%04%x: ", i * 16); // for (j = 0; j < 16; ++j) // { // printf("%02x ", pData[i*16+j]); // } // printf("\n"); //} // generate binary file //if (FALSE == genEepromBinFile(argv[3], EepromData)) { if (FALSE == genEepromBinFile(argv[3], pEepStruct )) { printf("Error creating EEPROM bin file %s \n", argv[3]); return -1; } else { printf(".created EEPROM bin file %s \n", argv[3]); } return 0; }
QByteArray AbstractMobileApp::generateDesktopFile(QString *errorMessage, int fileType) const { QByteArray desktopFileContent; if (!readTemplate(DesktopOrigin, &desktopFileContent, errorMessage)) return QByteArray(); if (fileType == AbstractGeneratedFileInfo::DesktopFileFremantle) { desktopFileContent.replace("Icon=thisApp", "Icon=" + projectName().toUtf8() + "64"); } else if (fileType == AbstractGeneratedFileInfo::DesktopFileHarmattan) { desktopFileContent.replace("Icon=thisApp", "Icon=/usr/share/icons/hicolor/80x80/apps/" + projectName().toUtf8() + "80.png"); desktopFileContent.replace("Exec=", "Exec=/usr/bin/single-instance "); } return desktopFileContent.replace("thisApp", projectName().toUtf8()); }
QString TemplateLayout::generate() { int progress = 0; int totalWork = getTotalWork(PrintOptions); QString htmlContent; delete m_engine; m_engine = new Grantlee::Engine(this); Grantlee::registerMetaType<template_options>(); Grantlee::registerMetaType<print_options>(); QVariantList diveList; struct dive *dive; int i; for_each_dive (i, dive) { //TODO check for exporting selected dives only if (!dive->selected && PrintOptions->print_selected) continue; DiveObjectHelper *d = new DiveObjectHelper(dive); diveList.append(QVariant::fromValue(d)); progress++; emit progressUpdated(lrint(progress * 100.0 / totalWork)); } Grantlee::Context c; c.insert("dives", diveList); c.insert("template_options", QVariant::fromValue(*templateOptions)); c.insert("print_options", QVariant::fromValue(*PrintOptions)); /* don't use the Grantlee loader API */ QString templateContents = readTemplate(PrintOptions->p_template); QString preprocessed = preprocessTemplate(templateContents); /* create the template from QString; is this thing allocating memory? */ Grantlee::Template t = m_engine->newTemplate(preprocessed, PrintOptions->p_template); if (!t || t->error()) { qDebug() << "Can't load template"; return htmlContent; } htmlContent = t->render(&c); if (t->error()) { qDebug() << "Can't render template"; } return htmlContent; }
QByteArray AbstractMobileApp::generateMainCpp(QString *errorMessage) const { QByteArray mainCppInput; if (!readTemplate(MainCppOrigin, &mainCppInput, errorMessage)) return QByteArray(); QTextStream in(&mainCppInput); QByteArray mainCppContent; QTextStream out(&mainCppContent, QIODevice::WriteOnly | QIODevice::Text); QString line; while (!(line = in.readLine()).isNull()) { bool adaptLine = true; if (line.contains(QLatin1String("// ORIENTATION"))) { const char *orientationString; switch (orientation()) { case ScreenOrientationLockLandscape: orientationString = "ScreenOrientationLockLandscape"; break; case ScreenOrientationLockPortrait: orientationString = "ScreenOrientationLockPortrait"; break; case ScreenOrientationAuto: orientationString = "ScreenOrientationAuto"; break; case ScreenOrientationImplicit: default: continue; // omit line } insertParameter(line, mainWindowClassName() + QLatin1String("::") + QLatin1String(orientationString)); } else if (line.contains(QLatin1String("// DELETE_LINE"))) { continue; // omit this line in the output } else { adaptLine = adaptCurrentMainCppTemplateLine(line); } if (adaptLine) { const int commentIndex = line.indexOf(QLatin1String(" //")); if (commentIndex != -1) line.truncate(commentIndex); out << line << endl; } } return mainCppContent; }
QByteArray AbstractMobileApp::generateProFile(QString *errorMessage) const { const QChar comment = QLatin1Char('#'); QByteArray proFileInput; if (!readTemplate(AppProOrigin, &proFileInput, errorMessage)) return QByteArray(); QTextStream in(&proFileInput); QByteArray proFileContent; QTextStream out(&proFileContent, QIODevice::WriteOnly | QIODevice::Text); QString valueOnNextLine; bool commentOutNextLine = false; QString line; while (!(line = in.readLine()).isNull()) { if (line.contains(QLatin1String("# TARGETUID3"))) { valueOnNextLine = symbianTargetUid(); } else if (line.contains(QLatin1String("# NETWORKACCESS")) && !networkEnabled()) { commentOutNextLine = true; } else if (line.contains(QLatin1String("# DEPLOYMENTFOLDERS"))) { // Eat lines QString nextLine; while (!(nextLine = in.readLine()).isNull() && !nextLine.contains(QLatin1String("# DEPLOYMENTFOLDERS_END"))) { } if (nextLine.isNull()) continue; int foldersCount = 0; QStringList folders; foreach (const DeploymentFolder &folder, deploymentFolders()) { foldersCount++; const QString folderName = QString::fromLatin1("folder_%1").arg(foldersCount, 2, 10, QLatin1Char('0')); out << folderName << ".source = " << folder.first << endl; if (!folder.second.isEmpty()) out << folderName << ".target = " << folder.second << endl; folders.append(folderName); } if (foldersCount > 0) out << "DEPLOYMENTFOLDERS = " << folders.join(QLatin1String(" ")) << endl; } else if (line.contains(QLatin1String("# REMOVE_NEXT_LINE"))) {
Recipe* readRecipe(char* filename) { FILE* file = fopen(filename,"r+"); if(file == NULL) printf("Error al abrir archivo"); //data char* idRecipe=(char*)malloc(sizeof(char)*ARRAY_SIZE_ID); int numTemplates=0; char** paths = NULL; Template** templates= NULL; //read fscanf(file, "%s", idRecipe); fscanf (file, "%d", &numTemplates); templates = (Template*)malloc(sizeof(Template*)* numTemplates); //memory paths=(char**)malloc(sizeof(char*)*ARRAY_SIZE_NAME); for(int i=0;i<numTemplates;i++){ paths[i]=(char*)malloc(sizeof(char)*ARRAY_SIZE_NAME); } for(int i=0;i<numTemplates;i++){ fscanf(file, "%s", paths[i]); int type=0; int numT=0; fscanf (file, "%d", &type); fscanf (file, "%d", &numT); templates[i]=readTemplate(paths[i],type,numT); } //fill Recipe* recipe=(Recipe*)malloc(sizeof(Recipe)); recipe->id=idRecipe; recipe->numTemplates=numTemplates; recipe->templates=templates; //free for(int i=0;i<numTemplates;i++){ free(paths[i]); } free(paths); fclose(file); return recipe; }
int main(int argc,char *argv[]) { tmplStruct tmpl; int i; char tmplFile[1024]; char fname[128]; char outName[128] = "ptime.tim"; FILE *fout; int logit=1; for (i=0;i<argc;i++) { if (strcmp(argv[i],"-f")==0) strcpy(tmplFile,argv[++i]); } initialiseTemplate(&tmpl); printf("Reading template\n"); readTemplate(tmplFile,&tmpl); printf("Complete reading template\n"); fout = fopen(outName,"w"); fprintf(fout,"FORMAT 1\n"); fflush(fout); // Now go through all the observations to process for (i=1;i<argc;i++) { if (strcmp(argv[i],"-f")==0){ i++; } else { strcpy(fname,argv[i]); processFile(fname,&tmpl,fout,logit); } } fclose(fout); // Should deallocate template memory }
void HtmlRenderer::process(Response& response, ResponseStream& stream, bool noContent) { m_iter = new ResponseIterator(response); m_response = &response; readTemplate(); { Replacement googleChart; m_reps.push_back(googleChart); Replacement& googleChartRep = m_reps.back(); googleChartRep.m_found = findGoogleChart(googleChartRep.m_open, googleChartRep.m_close); if (googleChartRep.m_found) { switch (m_iter->type()) { case TABLE_PROPERTIES: printGoogleChartProperties(response, stream); break; case TABLE_LIST: printGoogleChartList(response, stream); break; case TABLE_TIME_SERIES: printGoogleChartTimeSeries(response, stream); break; } return; } else { m_reps.clear(); } } switch (m_iter->type()) { case TABLE_PROPERTIES: printProperties(response, stream, noContent); break; case TABLE_LIST: THROW("Cannot plot list"); break; case TABLE_TIME_SERIES: printTimeSeries(response, stream, noContent); break; } }
int main(int argc, char **argv) { int c; char header[32768]; char temp [MAXSTR]; char fmt [MAXSTR]; char rfmt [MAXSTR]; char pfmt [MAXSTR]; char cfmt [MAXSTR]; char ofile [MAXSTR]; char scale [MAXSTR]; int i, j; int namelen, nimages, ntotal, stat; double xpos, ypos; double lon, lat; double oxpix, oypix; int oxpixMin, oypixMin; int oxpixMax, oypixMax; int offscl, mode; int ncols; FILE *fraw; FILE *fproj; FILE *fcorr; /***************************************/ /* Process the command-line parameters */ /***************************************/ debug = 0; opterr = 0; fstatus = stdout; while ((c = getopt(argc, argv, "ds:")) != EOF) { switch (c) { case 'd': debug = 1; break; case 's': if((fstatus = fopen(optarg, "w+")) == (FILE *)NULL) { printf("[struct stat=\"ERROR\", msg=\"Cannot open status file: %s\"]\n", optarg); exit(1); } break; default: printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-d][-s statusfile] images.tbl hdr.template raw.tbl projected.tbl corrected.tbl\"]\n", argv[0]); exit(1); break; } } if (argc - optind < 5) { printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-d][-s statusfile] images.tbl hdr.template raw.tbl projected.tbl corrected.tbl\"]\n", argv[0]); exit(1); } strcpy(origimg_file, argv[optind]); strcpy(template_file, argv[optind + 1]); strcpy(rawimg_file, argv[optind + 2]); strcpy(projimg_file, argv[optind + 3]); strcpy(corrimg_file, argv[optind + 4]); checkHdr(template_file, 1, 0); if(debug) { printf("\norigimg_file = [%s]\n", origimg_file); printf("template_file = [%s]\n\n", template_file); printf("rawimg_file = [%s]\n", rawimg_file); printf("projimg_file = [%s]\n", projimg_file); printf("corrimg_file = [%s]\n", corrimg_file); fflush(stdout); } /*************************************************/ /* Process the output header template to get the */ /* image size, coordinate system and projection */ /*************************************************/ readTemplate(template_file); if(debug) { printf("\noutput.sys = %d\n", output.sys); printf("output.epoch = %-g\n", output.epoch); printf("output proj = %s\n", output.wcs->ptype); fflush(stdout); } /*********************************************/ /* Open the image header metadata table file */ /*********************************************/ ncols = topen(origimg_file); if(ncols <= 0) { fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid image metadata file: %s\"]\n", origimg_file); exit(1); } icntr = tcol("cntr"); ictype1 = tcol("ctype1"); ictype2 = tcol("ctype2"); iequinox = tcol("equinox"); inl = tcol("nl"); ins = tcol("ns"); icrval1 = tcol("crval1"); icrval2 = tcol("crval2"); icrpix1 = tcol("crpix1"); icrpix2 = tcol("crpix2"); icdelt1 = tcol("cdelt1"); icdelt2 = tcol("cdelt2"); icrota2 = tcol("crota2"); iepoch = tcol("epoch"); ifname = tcol("fname"); iscale = tcol("scale"); icd11 = tcol("cd1_1"); icd12 = tcol("cd1_2"); icd21 = tcol("cd2_1"); icd22 = tcol("cd2_2"); if(ins < 0) ins = tcol("naxis1"); if(inl < 0) inl = tcol("naxis2"); if(ifname < 0) ifname = tcol("file"); if(icd11 >= 0 && icd12 >= 0 && icd21 >= 0 && icd12 >= 0) mode = CD; else if(icdelt1 >= 0 && icdelt2 >= 0 && icrota2 >= 0) mode = CDELT; else { fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Not enough information to determine coverages (CDELTs or CD matrix)\"]\n"); exit(1); } if(icntr < 0 || ictype1 < 0 || ictype2 < 0 || inl < 0 || ins < 0 || icrval1 < 0 || icrval2 < 0 || icrpix1 < 0 || icrpix2 < 0 || ifname < 0) { fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Need columns: cntr ctype1 ctype2 nl ns crval1 crval2 crpix1 crpix2 cdelt1 cdelt2 crota2 fname (equinox optional)\"]\n"); exit(1); } /******************************************************/ /* Scan the table to get the true 'file' column width */ /******************************************************/ namelen = 0; while(1) { stat = tread(); if(stat < 0) break; strcpy(input.fname, fileName(tval(ifname))); if(strlen(input.fname) > namelen) namelen = strlen(input.fname); } tseek(0); /*************************************/ /* Write headers to the output files */ /*************************************/ if((fraw = (FILE *)fopen(rawimg_file, "w+")) == (FILE *)NULL) { fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid output metadata file: %s\"]\n", rawimg_file); exit(1); } fprintf(fraw, "\\datatype=fitshdr\n"); if(iscale >= 0) { sprintf(fmt, "|%%5s|%%8s|%%8s|%%6s|%%6s|%%10s|%%10s|%%10s|%%10s|%%11s|%%11s|%%8s|%%7s|%%10s|%%%ds|\n", namelen+2); fprintf(fraw, fmt, "cntr", "ctype1", "ctype2", "naxis1", "naxis2", "crval1", "crval2", "crpix1", "crpix2", "cdelt1", "cdelt2", "crota2", "equinox", "scale", "file"); fprintf(fraw, fmt, "int", "char", "char", "int", "int", "double", "double", "double", "double", "double", "double", "double", "int", "double", "char"); } else { sprintf(fmt, "|%%5s|%%8s|%%8s|%%6s|%%6s|%%10s|%%10s|%%10s|%%10s|%%11s|%%11s|%%8s|%%7s|%%%ds|\n", namelen+2); fprintf(fraw, fmt, "cntr", "ctype1", "ctype2", "naxis1", "naxis2", "crval1", "crval2", "crpix1", "crpix2", "cdelt1", "cdelt2", "crota2", "equinox", "file"); fprintf(fraw, fmt, "int", "char", "char", "int", "int", "double", "double", "double", "double", "double", "double", "double", "int", "char"); } if((fproj = (FILE *)fopen(projimg_file, "w+")) == (FILE *)NULL) { fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid output metadata file: %s\"]\n", projimg_file); exit(1); } fprintf(fproj, "\\datatype=fitshdr\n"); sprintf(fmt, "|%%5s|%%8s|%%8s|%%6s|%%6s|%%10s|%%10s|%%10s|%%10s|%%11s|%%11s|%%8s|%%7s|%%%ds|\n", namelen+2); fprintf(fproj, fmt, "cntr", "ctype1", "ctype2", "naxis1", "naxis2", "crval1", "crval2", "crpix1", "crpix2", "cdelt1", "cdelt2", "crota2", "equinox", "file"); fprintf(fproj, fmt, "int", "char", "char", "int", "int", "double", "double", "double", "double", "double", "double", "double", "int", "char"); if((fcorr = (FILE *)fopen(corrimg_file, "w+")) == (FILE *)NULL) { fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid output metadata file: %s\"]\n", corrimg_file); exit(1); } fprintf(fcorr, "\\datatype=fitshdr\n"); fprintf(fcorr, fmt, "cntr", "ctype1", "ctype2", "naxis1", "naxis2", "crval1", "crval2", "crpix1", "crpix2", "cdelt1", "cdelt2", "crota2", "equinox", "file"); fprintf(fcorr, fmt, "int", "char", "char", "int", "int", "double", "double", "double", "double", "double", "double", "double", "int", "char"); /************************************************/ /* Read the metadata and process each image WCS */ /************************************************/ namelen = 0; nimages = 0; ntotal = 0; if(iscale >= 0) sprintf(rfmt, " %%5d %%8s %%8s %%6d %%6d %%10.6f %%10.6f %%10.2f %%10.2f %%11.8f %%11.8f %%8.5f %%7.0f %%10s %%%ds\n", namelen+2); else sprintf(rfmt, " %%5d %%8s %%8s %%6d %%6d %%10.6f %%10.6f %%10.2f %%10.2f %%11.8f %%11.8f %%8.5f %%7.0f %%%ds\n", namelen+2); sprintf(pfmt, " %%5d %%8s %%8s %%6d %%6d %%10.6f %%10.6f %%10.2f %%10.2f %%11.8f %%11.8f %%8.5f %%7.0f p%%%ds\n", namelen+2); sprintf(cfmt, " %%5d %%8s %%8s %%6d %%6d %%10.6f %%10.6f %%10.2f %%10.2f %%11.8f %%11.8f %%8.5f %%7.0f c%%%ds\n", namelen+2); while(1) { stat = tread(); if(stat < 0) break; ++ntotal; strcpy(input.ctype1, tval(ictype1)); strcpy(input.ctype2, tval(ictype2)); input.cntr = atoi(tval(icntr)); input.naxis1 = atoi(tval(ins)); input.naxis2 = atoi(tval(inl)); input.crpix1 = atof(tval(icrpix1)); input.crpix2 = atof(tval(icrpix2)); input.crval1 = atof(tval(icrval1)); input.crval2 = atof(tval(icrval2)); if(mode == CDELT) { input.cdelt1 = atof(tval(icdelt1)); input.cdelt2 = atof(tval(icdelt2)); input.crota2 = atof(tval(icrota2)); } else { input.cd11 = atof(tval(icd11)); input.cd12 = atof(tval(icd12)); input.cd21 = atof(tval(icd21)); input.cd22 = atof(tval(icd22)); } input.epoch = 2000; strcpy(header, ""); sprintf(temp, "SIMPLE = T" ); stradd(header, temp); sprintf(temp, "BITPIX = -64" ); stradd(header, temp); sprintf(temp, "NAXIS = 2" ); stradd(header, temp); sprintf(temp, "NAXIS1 = %d", input.naxis1 ); stradd(header, temp); sprintf(temp, "NAXIS2 = %d", input.naxis2 ); stradd(header, temp); sprintf(temp, "CTYPE1 = '%s'", input.ctype1 ); stradd(header, temp); sprintf(temp, "CTYPE2 = '%s'", input.ctype2 ); stradd(header, temp); sprintf(temp, "CRVAL1 = %11.6f", input.crval1 ); stradd(header, temp); sprintf(temp, "CRVAL2 = %11.6f", input.crval2 ); stradd(header, temp); sprintf(temp, "CRPIX1 = %11.6f", input.crpix1 ); stradd(header, temp); sprintf(temp, "CRPIX2 = %11.6f", input.crpix2 ); stradd(header, temp); if(mode == CDELT) { sprintf(temp, "CDELT1 = %11.6f", input.cdelt1 ); stradd(header, temp); sprintf(temp, "CDELT2 = %11.6f", input.cdelt2 ); stradd(header, temp); sprintf(temp, "CROTA2 = %11.6f", input.crota2 ); stradd(header, temp); } else { sprintf(temp, "CD1_1 = %11.6f", input.cd11 ); stradd(header, temp); sprintf(temp, "CD1_2 = %11.6f", input.cd12 ); stradd(header, temp); sprintf(temp, "CD2_1 = %11.6f", input.cd21 ); stradd(header, temp); sprintf(temp, "CD2_2 = %11.6f", input.cd22 ); stradd(header, temp); } sprintf(temp, "EQUINOX = %d", input.equinox); stradd(header, temp); sprintf(temp, "END" ); stradd(header, temp); if(iequinox >= 0) input.equinox = atoi(tval(iequinox)); strcpy(input.fname, fileName(tval(ifname))); if(iscale >= 0) strcpy(scale, tval(iscale)); if(strlen(input.fname) > namelen) namelen = strlen(input.fname); if(debug) { printf("Image header to wcsinit():\n%s\n", header); fflush(stdout); } input.wcs = wcsinit(header); checkWCS(input.wcs, 0); if(input.wcs == (struct WorldCoor *)NULL) { fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Bad WCS for image %d\"]\n", nimages); exit(1); } /***************************************************/ /* Check the boundaries of the input image against */ /* the output region of interest */ /***************************************************/ oxpixMin = 100000000; oxpixMax = -100000000; oypixMin = 100000000; oypixMax = -100000000; /* Check input left and right */ for (j=0; j<input.naxis2+1; ++j) { pix2wcs(input.wcs, 0.5, j+0.5, &xpos, &ypos); convertCoordinates(input.sys, input.epoch, xpos, ypos, output.sys, output.epoch, &lon, &lat, 0.0); wcs2pix(output.wcs, lon, lat, &oxpix, &oypix, &offscl); if(!offscl) { if(oxpix < oxpixMin) oxpixMin = oxpix; if(oxpix > oxpixMax) oxpixMax = oxpix; if(oypix < oypixMin) oypixMin = oypix; if(oypix > oypixMax) oypixMax = oypix; } pix2wcs(input.wcs, input.naxis1+0.5, j+0.5, &xpos, &ypos); convertCoordinates(input.sys, input.epoch, xpos, ypos, output.sys, output.epoch, &lon, &lat, 0.0); wcs2pix(output.wcs, lon, lat, &oxpix, &oypix, &offscl); if(!offscl) { if(oxpix < oxpixMin) oxpixMin = oxpix; if(oxpix > oxpixMax) oxpixMax = oxpix; if(oypix < oypixMin) oypixMin = oypix; if(oypix > oypixMax) oypixMax = oypix; } } /* Check input top and bottom */ for (i=0; i<input.naxis1+1; ++i) { pix2wcs(input.wcs, i+0.5, 0.5, &xpos, &ypos); convertCoordinates(input.sys, input.epoch, xpos, ypos, output.sys, output.epoch, &lon, &lat, 0.0); wcs2pix(output.wcs, lon, lat, &oxpix, &oypix, &offscl); if(!offscl) { if(oxpix < oxpixMin) oxpixMin = oxpix; if(oxpix > oxpixMax) oxpixMax = oxpix; if(oypix < oypixMin) oypixMin = oypix; if(oypix > oypixMax) oypixMax = oypix; } pix2wcs(input.wcs, i+0.5, input.naxis2+0.5, &xpos, &ypos); convertCoordinates(input.sys, input.epoch, xpos, ypos, output.sys, output.epoch, &lon, &lat, 0.0); wcs2pix(output.wcs, lon, lat, &oxpix, &oypix, &offscl); if(!offscl) { if(oxpix < oxpixMin) oxpixMin = oxpix; if(oxpix > oxpixMax) oxpixMax = oxpix; if(oypix < oypixMin) oypixMin = oypix; if(oypix > oypixMax) oypixMax = oypix; } } /***************************************************/ /* Check the boundaries of the region of interest */ /* against the input image */ /***************************************************/ /* Check ouput left and right */ for (j=0; j<output.wcs->nypix+1; ++j) { pix2wcs(output.wcs, 0.5, j+0.5, &xpos, &ypos); convertCoordinates(output.sys, output.epoch, xpos, ypos, input.sys, input.epoch, &lon, &lat, 0.0); wcs2pix(input.wcs, lon, lat, &oxpix, &oypix, &offscl); if(!offscl) { if(0.5 < oxpixMin) oxpixMin = 0.5; if(0.5 > oxpixMax) oxpixMax = 0.5; if(j+0.5 < oypixMin) oypixMin = j+0.5; if(j+0.5 > oypixMax) oypixMax = j+0.5; } pix2wcs(output.wcs, output.wcs->nxpix+0.5, j+0.5, &xpos, &ypos); convertCoordinates(output.sys, output.epoch, xpos, ypos, input.sys, input.epoch, &lon, &lat, 0.0); wcs2pix(input.wcs, lon, lat, &oxpix, &oypix, &offscl); if(!offscl) { if(output.wcs->nxpix+0.5 < oxpixMin) oxpixMin = output.wcs->nxpix+0.5; if(output.wcs->nxpix+0.5 > oxpixMax) oxpixMax = output.wcs->nxpix+0.5; if(j+0.5 < oypixMin) oypixMin = j+0.5; if(j+0.5 > oypixMax) oypixMax = j+0.5; } } /* Check input top and bottom */ for (i=0; i<output.wcs->nxpix+1; ++i) { pix2wcs(output.wcs, i+0.5, 0.5, &xpos, &ypos); convertCoordinates(output.sys, output.epoch, xpos, ypos, input.sys, input.epoch, &lon, &lat, 0.0); wcs2pix(input.wcs, lon, lat, &oxpix, &oypix, &offscl); if(!offscl) { if(i+0.5 < oxpixMin) oxpixMin = i+0.5; if(i+0.5 > oxpixMax) oxpixMax = i+0.5; if(0.5 < oypixMin) oypixMin = 0.5 ; if(0.5 > oypixMax) oypixMax = 0.5 ; } pix2wcs(output.wcs, i+0.5, output.wcs->nypix+0.5, &xpos, &ypos); convertCoordinates(output.sys, output.epoch, xpos, ypos, input.sys, input.epoch, &lon, &lat, 0.0); wcs2pix(input.wcs, lon, lat, &oxpix, &oypix, &offscl); if(!offscl) { if(i+0.5 < oxpixMin) oxpixMin = i+0.5; if(i+0.5 > oxpixMax) oxpixMax = i+0.5; if(output.wcs->nypix+0.5 < oypixMin) oypixMin = output.wcs->nypix+0.5; if(output.wcs->nypix+0.5 > oypixMax) oypixMax = output.wcs->nypix+0.5; } } if(oxpixMax < oxpixMin) continue; if(oypixMax < oypixMin) continue; /* Remove any possible compression extension */ strcpy(ofile, input.fname); if(strlen(ofile) > 3 && strcmp(ofile+strlen(ofile)-3, ".gz") == 0) ofile[strlen(ofile)-3] = '\0'; else if(strlen(ofile) > 2 && strcmp(ofile+strlen(ofile)-2, ".Z") == 0) ofile[strlen(ofile)-2] = '\0'; else if(strlen(ofile) > 2 && strcmp(ofile+strlen(ofile)-2, ".z") == 0) ofile[strlen(ofile)-2] = '\0'; else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".zip") == 0) ofile[strlen(ofile)-4] = '\0'; else if(strlen(ofile) > 2 && strcmp(ofile+strlen(ofile)-2, "-z") == 0) ofile[strlen(ofile)-2] = '\0'; else if(strlen(ofile) > 3 && strcmp(ofile+strlen(ofile)-3, "-gz") == 0) ofile[strlen(ofile)-3] = '\0'; /* Make sure the extension is ".fits" */ if(strlen(ofile) > 5 && strcmp(ofile+strlen(ofile)-5, ".fits") == 0) ofile[strlen(ofile)-5] = '\0'; else if(strlen(ofile) > 5 && strcmp(ofile+strlen(ofile)-5, ".FITS") == 0) ofile[strlen(ofile)-5] = '\0'; else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".fit") == 0) ofile[strlen(ofile)-4] = '\0'; else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".FIT") == 0) ofile[strlen(ofile)-4] = '\0'; else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".fts") == 0) ofile[strlen(ofile)-4] = '\0'; else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".FTS") == 0) ofile[strlen(ofile)-4] = '\0'; strcat(ofile, ".fits"); if(iscale >= 0) { fprintf(fraw, rfmt, nimages+1, output.wcs->ctype[0], output.wcs->ctype[1], oxpixMax - oxpixMin + 1, oypixMax - oypixMin + 1, output.wcs->crval[0], output.wcs->crval[1], output.wcs->crpix[0] - oxpixMin, output.wcs->crpix[1] - oypixMin, output.wcs->cdelt[0], output.wcs->cdelt[1], output.wcs->rot, output.epoch, scale, ofile); } else { fprintf(fraw, rfmt, nimages+1, output.wcs->ctype[0], output.wcs->ctype[1], oxpixMax - oxpixMin + 1, oypixMax - oypixMin + 1, output.wcs->crval[0], output.wcs->crval[1], output.wcs->crpix[0] - oxpixMin, output.wcs->crpix[1] - oypixMin, output.wcs->cdelt[0], output.wcs->cdelt[1], output.wcs->rot, output.epoch, ofile); } fprintf(fproj, pfmt, nimages+1, output.wcs->ctype[0], output.wcs->ctype[1], oxpixMax - oxpixMin + 1, oypixMax - oypixMin + 1, output.wcs->crval[0], output.wcs->crval[1], output.wcs->crpix[0] - oxpixMin, output.wcs->crpix[1] - oypixMin, output.wcs->cdelt[0], output.wcs->cdelt[1], output.wcs->rot, output.epoch, ofile); fprintf(fcorr, cfmt, nimages+1, output.wcs->ctype[0], output.wcs->ctype[1], oxpixMax - oxpixMin + 1, oypixMax - oypixMin + 1, output.wcs->crval[0], output.wcs->crval[1], output.wcs->crpix[0] - oxpixMin, output.wcs->crpix[1] - oypixMin, output.wcs->cdelt[0], output.wcs->cdelt[1], output.wcs->rot, output.epoch, ofile); ++nimages; } fclose(fraw); fclose(fproj); fclose(fcorr); fprintf(fstatus, "[struct stat=\"OK\", count=\"%d\", total=\"%d\"]\n", nimages, ntotal); fflush(stdout); exit(0); }
int main(int argc, char **argv) { int i, j, l, m, c, count, ismag, ncol; int dl, dm, width, haveFlux, isImg, csys; int side, ibegin, iend, nstep, useCenter; int racol, deccol, fluxcol; int ra1col, dec1col; int ra2col, dec2col; int ra3col, dec3col; int ra4col, dec4col; long fpixel, nelements; double rac, decc; double ra[4], dec[4]; double x, y, z; double x0, y0, z0; double x1, y1, z1; double oxpix, oypix, equinox; int offscl; double ilon; double ilat; double pixscale, len, sideLength, dtr; double offset; double xn, yn, zn; double ran, decn; double sina, cosa; double sind, cosd; double a11, a12, a13; double a21, a22, a23; double a31, a32, a33; double x0p, y0p, z0p; double x1p, y1p, z1p; double lon0, lon1; double xp, yp; double lon; double pixel_value; double weights[5][5]; double weights3[5][5] = {{0.0, 0.0, 0.0, 0.0, 0.0}, {0.0, 0.1, 0.2, 0.1, 0.0}, {0.0, 0.2, 1.0, 0.2, 0.0}, {0.0, 0.1, 0.2, 0.1, 0.0}, {0.0, 0.0, 0.0, 0.0, 0.0}}; double weights5[5][5] = {{0.0, 0.1, 0.2, 0.1, 0.0}, {0.1, 0.3, 0.5, 0.3, 0.1}, {0.2, 0.5, 1.0, 0.5, 0.2}, {0.1, 0.3, 0.5, 0.3, 0.1}, {0.0, 0.1, 0.2, 0.1, 0.0}}; double **data; int status = 0; char input_file [MAXSTR]; char colname [MAXSTR]; char output_file [MAXSTR]; char template_file[MAXSTR]; int bitpix = DOUBLE_IMG; long naxis = 2; double sumweights; double refmag; dtr = atan(1.0)/45.; /***************************************/ /* Process the command-line parameters */ /***************************************/ ismag = 0; opterr = 0; useCenter = 0; strcpy(colname, ""); while ((c = getopt(argc, argv, "pm:d:w:c:")) != EOF) { switch (c) { case 'm': ismag = 1; refmag = atof(optarg); break; case 'd': debug = debugCheck(optarg); break; case 'w': width = atoi(optarg); break; case 'c': strcpy(colname, optarg); break; case 'p': useCenter = 1; break; default: printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-c column][-m refmag][-d level][-w size] in.tbl out.fits hdr.template\"]\n", argv[0]); exit(1); break; } } if (argc - optind < 3) { printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-c column][-m refmag][-d level][-w size] in.tbl out.fits hdr.template\"]\n", argv[0]); exit(1); } strcpy(input_file, argv[optind]); strcpy(output_file, argv[optind+1]); strcpy(template_file, argv[optind+2]); if(debug >= 1) { printf("input_file = [%s]\n", input_file); printf("colname = [%s]\n", colname); printf("output_file = [%s]\n", output_file); printf("template_file = [%s]\n", template_file); printf("width = %d\n", width); printf("ismag = %d\n", ismag); fflush(stdout); } /********************************************/ /* Set the weights for spreading the points */ /********************************************/ sumweights = 0.; for(i=0; i<5; ++i) { for(j=0; j<5; ++j) { if(width == 3) sumweights += weights3[i][j]; else if(width == 5) sumweights += weights5[i][j]; } } for(i=0; i<5; ++i) { for(j=0; j<5; ++j) { if(width == 3) weights[i][j] = weights3[i][j]/sumweights; else if(width == 5) weights[i][j] = weights5[i][j]/sumweights; else weights[i][j] = 0.; } } if(width != 3 && width != 5) weights[2][2] = 1.; /************************************************/ /* Open the table file and find the data column */ /************************************************/ ncol = topen(input_file); if(ncol <= 0) { printf("[struct stat=\"ERROR\", msg=\"Can't open input table %s\"]\n", input_file); exit(0); } racol = tcol( "ra"); deccol = tcol("dec"); ra1col = tcol( "ra1"); dec1col = tcol("dec1"); ra2col = tcol( "ra2"); dec2col = tcol("dec2"); ra3col = tcol( "ra3"); dec3col = tcol("dec3"); ra4col = tcol( "ra4"); dec4col = tcol("dec4"); haveFlux = 1; if(strlen(colname) == 0) haveFlux = 0; else fluxcol = tcol(colname); isImg = 1; if(ra1col < 0 || dec1col < 0 || ra2col < 0 || dec2col < 0 || ra3col < 0 || dec3col < 0 || ra4col < 0 || dec4col < 0) isImg = 0; if(useCenter) isImg = 0; if(!isImg) { if(racol < 0) { printf("[struct stat=\"ERROR\", msg=\"Can't find column 'ra'\"]\n"); exit(0); } if(deccol < 0) { printf("[struct stat=\"ERROR\", msg=\"Can't find column 'dec'\"]\n"); exit(0); } } if(haveFlux && fluxcol < 0) { printf("[struct stat=\"ERROR\", msg=\"Can't find column '%s'\"]\n", colname); exit(0); } /*************************************************/ /* Process the output header template to get the */ /* image size, coordinate system and projection */ /*************************************************/ readTemplate(template_file); pixscale = fabs(output.wcs->xinc); if(fabs(output.wcs->yinc) > pixscale) pixscale = fabs(output.wcs->yinc); csys = EQUJ; if(strncmp(output.wcs->c1type, "RA", 2) == 0) csys = EQUJ; if(strncmp(output.wcs->c1type, "GLON", 4) == 0) csys = GAL; if(strncmp(output.wcs->c1type, "ELON", 4) == 0) csys = ECLJ; equinox = output.wcs->equinox; if(debug >= 1) { printf("output.naxes[0] = %ld\n", output.naxes[0]); printf("output.naxes[1] = %ld\n", output.naxes[1]); printf("output.sys = %d\n", output.sys); printf("output.epoch = %-g\n", output.epoch); printf("output proj = %s\n", output.wcs->ptype); printf("output crval[0] = %-g\n", output.wcs->crval[0]); printf("output crval[1] = %-g\n", output.wcs->crval[1]); printf("output crpix[0] = %-g\n", output.wcs->crpix[0]); printf("output crpix[1] = %-g\n", output.wcs->crpix[1]); printf("output cdelt[0] = %-g\n", output.wcs->cdelt[0]); printf("output cdelt[1] = %-g\n", output.wcs->cdelt[1]); fflush(stdout); } /***********************************************/ /* Allocate memory for the output image pixels */ /***********************************************/ data = (double **)malloc(output.naxes[1] * sizeof(double *)); data[0] = (double *)malloc(output.naxes[0] * output.naxes[1] * sizeof(double)); if(debug >= 1) { printf("%ld bytes allocated for image pixels\n", output.naxes[0] * output.naxes[1] * sizeof(double)); fflush(stdout); } /**********************************************************/ /* Initialize pointers to the start of each row of pixels */ /**********************************************************/ for(i=1; i<output.naxes[1]; i++) data[i] = data[i-1] + output.naxes[0]; if(debug >= 1) { printf("pixel line pointers populated\n"); fflush(stdout); } for (j=0; j<output.naxes[1]; ++j) { for (i=0; i<output.naxes[0]; ++i) { data[j][i] = 0.; } } /************************/ /* Create the FITS file */ /************************/ remove(output_file); if(fits_create_file(&output.fptr, output_file, &status)) printFitsError(status); /*********************************************************/ /* Create the FITS image. All the required keywords are */ /* handled automatically. */ /*********************************************************/ if (fits_create_img(output.fptr, bitpix, naxis, output.naxes, &status)) printFitsError(status); if(debug >= 1) { printf("FITS image created (not yet populated)\n"); fflush(stdout); } /*****************************/ /* Loop over the input files */ /*****************************/ time(&currtime); start = currtime; /*******************/ /* For each source */ /*******************/ count = 0; while(tread() >= 0) { ++count; if(isImg) { if(debug && count/1000*1000 == count) { printf("%9d image outlines processed\n", count); fflush(stdout); } ra [0] = atof(tval( ra1col)); dec[0] = atof(tval(dec1col)); ra [1] = atof(tval( ra2col)); dec[1] = atof(tval(dec2col)); ra [2] = atof(tval( ra3col)); dec[2] = atof(tval(dec3col)); ra [3] = atof(tval( ra4col)); dec[3] = atof(tval(dec4col)); for(side=0; side<4; ++side) { ibegin = side; iend = (side+1)%4; x0 = cos(ra[ibegin]*dtr) * cos(dec[ibegin]*dtr); y0 = sin(ra[ibegin]*dtr) * cos(dec[ibegin]*dtr); z0 = sin(dec[ibegin]*dtr); x1 = cos(ra[iend]*dtr) * cos(dec[iend]*dtr); y1 = sin(ra[iend]*dtr) * cos(dec[iend]*dtr); z1 = sin(dec[iend]*dtr); xn = y0*z1 - z0*y1; yn = z0*x1 - x0*z1; zn = x0*y1 - y0*x1; len = sqrt(xn*xn + yn*yn + zn*zn); xn = xn / len; yn = yn / len; zn = zn / len; ran = atan2(yn, xn); decn = asin(zn); sina = sin(ran); cosa = cos(ran); sind = sin(decn); cosd = cos(decn); a11 = cosa*sind; a12 = sina*sind; a13 = -cosd; a21 = -sina; a22 = cosa; a23 = 0.; a31 = cosa*cosd; a32 = sina*cosd; a33 = sind; x0p = a11*x0 + a12*y0 + a13*z0; y0p = a21*x0 + a22*y0 + a23*z0; z0p = a31*x0 + a32*y0 + a33*z0; x1p = a11*x1 + a12*y1 + a13*z1; y1p = a21*x1 + a22*y1 + a23*z1; z1p = a31*x1 + a32*y1 + a33*z1; lon0 = atan2(y0p, x0p); lon1 = atan2(y1p, x1p); if(fabs(lon1-lon0)/dtr > 180.) { if(lon0 < 0.) lon0 += 360.*dtr; if(lon1 < 0.) lon1 += 360.*dtr; } sideLength = acos(x0*x1 + y0*y1 + z0*z1) / dtr; offset = pixscale/2.*dtr; if(lon0 > lon1) offset = -offset; nstep = (lon1 - lon0)/offset; lon = lon0; for(i=0; i<nstep; ++i) { lon += offset; xp = cos(lon); yp = sin(lon); x = a11*xp + a21*yp; y = a12*xp + a22*yp; z = a13*xp + a23*yp; rac = atan2(y,x)/dtr; decc = asin(z)/dtr; convertCoordinates (EQUJ, 2000., rac, decc, csys, equinox, &ilon, &ilat, 0.); offscl = 0; wcs2pix(output.wcs, ilon, ilat, &oxpix, &oypix, &offscl); fixxy(&oxpix, &oypix, &offscl); if(haveFlux) pixel_value = atof(tval(fluxcol)); else pixel_value = 1; l = (int)(oxpix + 0.5) - 1; m = (int)(oypix + 0.5) - 1; if(!offscl) data[m][l] = pixel_value; } } } else { if(debug && count/1000*1000 == count) { printf("%9d sources processed\n", count); fflush(stdout); } rac = atof(tval(racol)); decc = atof(tval(deccol)); convertCoordinates (EQUJ, 2000., rac, decc, csys, equinox, &ilon, &ilat, 0.); if(haveFlux) pixel_value = atof(tval(fluxcol)); else pixel_value = 1; if(ismag) pixel_value = pow(10., 0.4 * (refmag - pixel_value)); wcs2pix(output.wcs, ilon, ilat, &oxpix, &oypix, &offscl); if(pixel_value < 1.e10) { if(debug >= 3) { printf(" value = %11.3e at coord = (%12.8f,%12.8f)", pixel_value, ilon, ilat); if(offscl) { printf(" -> opix = (%7.1f,%7.1f) OFF SCALE\n", oxpix, oypix); fflush(stdout); } else { printf(" -> opix = (%7.1f,%7.1f)\n", oxpix, oypix); fflush(stdout); } } else if(pixel_value > 1000000.) { printf(" value = %11.3e at coord = (%12.8f,%12.8f)", pixel_value, ilon, ilat); if(offscl) { printf(" -> opix = (%7.1f,%7.1f) OFF SCALE\n", oxpix, oypix); fflush(stdout); } else { printf(" -> opix = (%7.1f,%7.1f)\n", oxpix, oypix); fflush(stdout); } } if(!offscl) { l = (int)(oxpix + 0.5) - 1; m = (int)(oypix + 0.5) - 1; if(l < 0 || m < 0 || l >= output.naxes[0] || m >= output.naxes[1]) { /* printf("ERROR: l=%d, m=%d\n", l, m); fflush(stdout); */ } else { for(dl=-2; dl<=2; ++dl) { if(l+dl < 0 || l+dl>= output.naxes[0]) continue; for(dm=-2; dm<=2; ++dm) { if(m+dm < 0 || m+dm>= output.naxes[1]) continue; data[m+dm][l+dl] += weights[dm+2][dl+2] * pixel_value; } } } } } } } /************************/ /* Write the image data */ /************************/ fpixel = 1; nelements = output.naxes[0] * output.naxes[1]; if (fits_write_img(output.fptr, TDOUBLE, fpixel, nelements, data[0], &status)) printFitsError(status); if(debug >= 1) { printf("Data array written to FITS image\n"); fflush(stdout); } /*************************************/ /* Add keywords from a template file */ /*************************************/ if(fits_write_key_template(output.fptr, template_file, &status)) printFitsError(status); if(debug >= 1) { printf("Template keywords written to FITS image\n"); fflush(stdout); } /***********************/ /* Close the FITS file */ /***********************/ if(fits_close_file(output.fptr, &status)) printFitsError(status); if(debug >= 1) { printf("FITS image finalized\n"); fflush(stdout); } time(&currtime); printf("[struct stat=\"OK\", time=%d]\n", (int)(currtime - start)); fflush(stdout); exit(0); }
int main(int argc, char **argv) { int i, j, c, ifile, status; long fpixel[4], nelements; int nullcnt; int imin, jmin, haveMinMax; int imax, jmax; int istart, iend, ilength; int jstart, jend, jlength; double *buffer, *abuffer; double datamin, datamax; double areamin, areamax; int narea1, narea2; double avearea1, avearea2; double maxarea1, maxarea2; double pixel_value; double **data; double **area; char template_file[MAXSTR]; char line [MAXSTR]; char infile[2][MAXSTR]; char inarea[2][MAXSTR]; /*************************************************/ /* Initialize output FITS basic image parameters */ /*************************************************/ int bitpix = DOUBLE_IMG; long naxis = 2; /************************************************/ /* Make a NaN value to use setting blank pixels */ /************************************************/ union { double d; char c[8]; } value; double nan; for(i=0; i<8; ++i) value.c[i] = 255; nan = value.d; /***************************************/ /* Process the command-line parameters */ /***************************************/ debug = 0; noAreas = 0; coverageLimit = 0.0001; opterr = 0; fstatus = stdout; while ((c = getopt(argc, argv, "nc:d:s:")) != EOF) { switch (c) { case 'n': noAreas = 1; break; case 'c': coverageLimit = atof(optarg); break; case 'd': debug = debugCheck(optarg); break; case 's': if((fstatus = fopen(optarg, "w+")) == (FILE *)NULL) { printf("[struct stat=\"ERROR\", msg=\"Cannot open status file: %s\"]\n", optarg); exit(1); } break; default: printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-d level] [-n(o-areas)] [-s statusfile] in1.fits in2.fits out.fits hdr.template\"]\n", argv[0]); exit(1); break; } } if (argc - optind < 4) { printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-d level] [-n(o-areas)] [-s statusfile] in1.fits in2.fits out.fits hdr.template\"]\n", argv[0]); exit(1); } strcpy(input_file1, argv[optind]); strcpy(input_file2, argv[optind + 1]); strcpy(output_file, argv[optind + 2]); strcpy(template_file, argv[optind + 3]); checkHdr(template_file, 1, 0); if(strlen(output_file) > 5 && strncmp(output_file+strlen(output_file)-5, ".fits", 5) == 0) output_file[strlen(output_file)-5] = '\0'; strcpy(output_area_file, output_file); strcat(output_file, ".fits"); strcat(output_area_file, "_area.fits"); if(debug >= 1) { printf("input_file1 = [%s]\n", input_file1); printf("input_file2 = [%s]\n", input_file2); printf("output_file = [%s]\n", output_file); printf("output_area_file = [%s]\n", output_area_file); printf("template_file = [%s]\n", template_file); fflush(stdout); } /****************************/ /* Get the input file names */ /****************************/ if(strlen(input_file1) > 5 && strcmp(input_file1+strlen(input_file1)-5, ".fits") == 0) { strcpy(line, input_file1); line[strlen(line)-5] = '\0'; strcpy(infile[0], line); strcat(infile[0], ".fits"); strcpy(inarea[0], line); strcat(inarea[0], "_area.fits"); } else { strcpy(infile[0], input_file1); strcat(infile[0], ".fits"); strcpy(inarea[0], input_file1); strcat(inarea[0], "_area.fits"); } if(strlen(input_file2) > 5 && strcmp(input_file2+strlen(input_file2)-5, ".fits") == 0) { strcpy(line, input_file2); line[strlen(line)-5] = '\0'; strcpy(infile[1], line); strcat(infile[1], ".fits"); strcpy(inarea[1], line); strcat(inarea[1], "_area.fits"); } else { strcpy(infile[1], input_file2); strcat(infile[1], ".fits"); strcpy(inarea[1], input_file2); strcat(inarea[1], "_area.fits"); } if(debug >= 1) { printf("\ninput files:\n\n"); printf(" [%s][%s]\n", infile[0], inarea[0]); printf(" [%s][%s]\n", infile[1], inarea[1]); printf("\n"); } /*************************************************/ /* Process the output header template to get the */ /* image size, coordinate system and projection */ /*************************************************/ readTemplate(template_file); if(debug >= 1) { printf("output.naxes[0] = %ld\n", output.naxes[0]); printf("output.naxes[1] = %ld\n", output.naxes[1]); printf("output.crpix1 = %-g\n", output.crpix1); printf("output.crpix2 = %-g\n", output.crpix2); fflush(stdout); } /*****************************************************/ /* We open the two input files briefly to get enough */ /* information to determine the region of overlap */ /* (for memory allocation purposes) */ /*****************************************************/ readFits(infile[0], inarea[0]); imin = output.crpix1 - input.crpix1; jmin = output.crpix2 - input.crpix2; imax = imin + input.naxes[0]; jmax = jmin + input.naxes[1]; istart = imin; iend = imax; jstart = jmin; jend = jmax; if(debug >= 1) { printf("\nFile 1:\n"); printf("input.naxes[0] = %ld\n", input.naxes[0]); printf("input.naxes[1] = %ld\n", input.naxes[1]); printf("input.crpix1 = %-g\n", input.crpix1); printf("input.crpix2 = %-g\n", input.crpix2); printf("imin = %d\n", imin); printf("imax = %d\n", imax); printf("jmin = %d\n", jmin); printf("jmax = %d\n\n", jmax); printf("istart = %d\n", istart); printf("iend = %d\n", iend); printf("jstart = %d\n", jstart); printf("jend = %d\n", jend); fflush(stdout); } status = 0; if(fits_close_file(input.fptr, &status)) printFitsError(status); if(!noAreas) { if(fits_close_file(input_area.fptr, &status)) printFitsError(status); } readFits(infile[1], inarea[1]); imin = output.crpix1 - input.crpix1; jmin = output.crpix2 - input.crpix2; imax = imin + input.naxes[0]; jmax = jmin + input.naxes[1]; if(debug >= 1) { printf("\nFile 2:\n"); printf("input.naxes[0] = %ld\n", input.naxes[0]); printf("input.naxes[1] = %ld\n", input.naxes[1]); printf("input.crpix1 = %-g\n", input.crpix1); printf("input.crpix2 = %-g\n", input.crpix2); printf("imin = %d\n", imin); printf("imax = %d\n", imax); printf("jmin = %d\n", jmin); printf("jmax = %d\n", jmax); printf("istart = %d\n\n", istart); printf("iend = %d\n", iend); printf("jstart = %d\n", jstart); printf("jend = %d\n", jend); printf("\n"); fflush(stdout); } if(imin > istart) istart = imin; if(imax < iend ) iend = imax; if(jmin > jstart) jstart = jmin; if(jmax < jend ) jend = jmax; if(istart < 0) istart = 0; if(jstart < 0) jstart = 0; if(iend > output.naxes[0]-1) iend = output.naxes[0]-1; if(jend > output.naxes[1]-1) jend = output.naxes[1]-1; ilength = iend - istart + 1; jlength = jend - jstart + 1; if(debug >= 1) { printf("\nComposite:\n"); printf("input.naxes[0] = %ld\n", input.naxes[0]); printf("input.naxes[1] = %ld\n", input.naxes[1]); printf("input.crpix1 = %-g\n", input.crpix1); printf("input.crpix2 = %-g\n", input.crpix2); printf("istart = %d\n", istart); printf("iend = %d\n", iend); printf("jstart = %d\n", jstart); printf("jend = %d\n", jend); printf("ilength = %d\n", ilength); printf("jlength = %d\n", jlength); printf("\n"); fflush(stdout); } if(fits_close_file(input.fptr, &status)) printFitsError(status); if(!noAreas) { if(fits_close_file(input_area.fptr, &status)) printFitsError(status); } /*********************/ /* Check for overlap */ /*********************/ if(ilength <= 0 || jlength <= 0) printError("Images don't overlap"); /***********************************************/ /* Allocate memory for the output image pixels */ /***********************************************/ data = (double **)malloc(jlength * sizeof(double *)); for(j=0; j<jlength; ++j) data[j] = (double *)malloc(ilength * sizeof(double)); if(debug >= 1) { printf("%d bytes allocated for image pixels\n", ilength * jlength * sizeof(double)); fflush(stdout); } /****************************/ /* Initialize data to zeros */ /****************************/ for (j=0; j<jlength; ++j) { for (i=0; i<ilength; ++i) { data[j][i] = 0.; } } /**********************************************/ /* Allocate memory for the output pixel areas */ /**********************************************/ area = (double **)malloc(jlength * sizeof(double *)); for(j=0; j<jlength; ++j) area[j] = (double *)malloc(ilength * sizeof(double)); if(debug >= 1) { printf("%d bytes allocated for pixel areas\n", ilength * jlength * sizeof(double)); fflush(stdout); } /****************************/ /* Initialize area to zeros */ /****************************/ for (j=0; j<jlength; ++j) { for (i=0; i<ilength; ++i) { area[j][i] = 0.; } } /***************************/ /* For the two input files */ /***************************/ time(&currtime); start = currtime; avearea1 = 0.; avearea2 = 0.; maxarea1 = 0.; maxarea2 = 0.; narea1 = 0.; narea2 = 0.; for(ifile=0; ifile<2; ++ifile) { /************************/ /* Read the input image */ /************************/ readFits(infile[ifile], inarea[ifile]); imin = output.crpix1 - input.crpix1; jmin = output.crpix2 - input.crpix2; if(debug >= 1) { printf("\nflux file = %s\n", infile[ifile]); printf("input.naxes[0] = %ld\n", input.naxes[0]); printf("input.naxes[1] = %ld\n", input.naxes[1]); printf("input.crpix1 = %-g\n", input.crpix1); printf("input.crpix2 = %-g\n", input.crpix2); printf("\narea file = %s\n", inarea[ifile]); printf("input_area.naxes[0] = %ld\n", input.naxes[0]); printf("input_area.naxes[1] = %ld\n", input.naxes[1]); printf("input_area.crpix1 = %-g\n", input.crpix1); printf("input_area.crpix2 = %-g\n", input.crpix2); printf("\nimin = %d\n", imin); printf("jmin = %d\n\n", jmin); fflush(stdout); } /**********************************************************/ /* Create the output array by processing the input pixels */ /**********************************************************/ buffer = (double *)malloc(input.naxes[0] * sizeof(double)); abuffer = (double *)malloc(input.naxes[0] * sizeof(double)); fpixel[0] = 1; fpixel[1] = 1; fpixel[2] = 1; fpixel[3] = 1; nelements = input.naxes[0]; status = 0; /*****************************/ /* Loop over the input lines */ /*****************************/ for (j=0; j<input.naxes[1]; ++j) { if(debug >= 2) { printf("\rProcessing input row %5d ", j); fflush(stdout); } /***********************************/ /* Read a line from the input file */ /***********************************/ if(fits_read_pix(input.fptr, TDOUBLE, fpixel, nelements, NULL, buffer, &nullcnt, &status)) printFitsError(status); if(noAreas) { for(i=0; i<input.naxes[0]; ++i) abuffer[i] = 1.; } else { if(fits_read_pix(input_area.fptr, TDOUBLE, fpixel, nelements, NULL, abuffer, &nullcnt, &status)) printFitsError(status); } ++fpixel[1]; /************************/ /* For each input pixel */ /************************/ for (i=0; i<input.naxes[0]; ++i) { pixel_value = buffer[i] * abuffer[i]; if(debug >= 4) { printf("input: line %5d / pixel %5d, value = %10.2e (%10.2e) [array: %5d %5d]\n", j, i, buffer[i], abuffer[i], j+jmin-jstart, i+imin-istart); fflush(stdout); } if(i+imin < istart) continue; if(j+jmin < jstart) continue; if(i+imin >= iend) continue; if(j+jmin >= jend) continue; if(debug >= 3) { printf("keep: line %5d / pixel %5d, value = %10.2e (%10.2e) [array: %5d %5d]\n", j, i, buffer[i], abuffer[i], j+jmin-jstart, i+imin-istart); fflush(stdout); } if(ifile == 0) { if(mNaN(buffer[i]) || abuffer[i] <= 0.) { if(debug >= 5) { printf("First file. Setting data to NaN and area to zero.\n"); fflush(stdout); } data[j+jmin-jstart][i+imin-istart] = nan; area[j+jmin-jstart][i+imin-istart] = 0.; if(debug >= 5) { printf("done.\n"); fflush(stdout); } continue; } else { if(debug >= 5) { printf("First file. Setting data to pixel value.\n"); fflush(stdout); } data[j+jmin-jstart][i+imin-istart] = pixel_value; area[j+jmin-jstart][i+imin-istart] = abuffer[i]; ++narea1; avearea1 += abuffer[i]; if(abuffer[i] > maxarea1) maxarea1 = abuffer[i]; if(debug >= 5) { printf("done.\n"); fflush(stdout); } } } else { if(mNaN(buffer[i]) || abuffer[i] <= 0. || data[j+jmin-jstart][i+imin-istart] == nan || area[j+jmin-jstart][i+imin-istart] == 0.) { if(debug >= 5) { printf("Second file. One or the other value is NaN (or zero area).\n"); fflush(stdout); } data[j+jmin-jstart][i+imin-istart] = nan; area[j+jmin-jstart][i+imin-istart] = 0.; continue; } else { if(debug >= 5) { printf("Second file. Subtracting pixel value.\n"); fflush(stdout); } data[j+jmin-jstart][i+imin-istart] -= pixel_value; area[j+jmin-jstart][i+imin-istart] += abuffer[i]; ++narea2; avearea2 += abuffer[i]; if(abuffer[i] > maxarea2) maxarea2 = abuffer[i]; if(debug >= 5) { printf("done.\n"); fflush(stdout); } } } } } free(buffer); free(abuffer); if(fits_close_file(input.fptr, &status)) printFitsError(status); if(!noAreas) { if(fits_close_file(input_area.fptr, &status)) printFitsError(status); } } if(debug >= 1) { time(&currtime); printf("\nDone reading data (%.0f seconds)\n", (double)(currtime - start)); fflush(stdout); } /************************************/ /* Anly keep those pixels that were */ /* covered twice reasonably fully */ /************************************/ avearea1 = avearea1/narea1; avearea2 = avearea2/narea2; areamax = maxarea1 + maxarea2; if(debug >= 2) { printf("\npixel areas: %-g + %-g = %-g\n\n", avearea1, avearea2, areamax); fflush(stdout); } for (j=0; j<jlength; ++j) { for (i=0; i<ilength; ++i) { if(mNaN(area[j][i]) || area[j][i] == 0.) { data[j][i] = 0.; area[j][i] = 0.; } else { if(fabs(area[j][i] - areamax)/areamax > coverageLimit) { data[j][i] = 0.; area[j][i] = 0.; } } } } /*********************************/ /* Normalize image data based on */ /* total area added to pixel */ /*********************************/ haveMinMax = 0; datamax = 0., datamin = 0.; areamin = 0.; areamax = 0.; imin = 99999; imax = 0; jmin = 99999; jmax = 0; for (j=0; j<jlength; ++j) { for (i=0; i<ilength; ++i) { if(area[j][i] > 0.) { data[j][i] = 2. * data[j][i] / area[j][i]; if(!haveMinMax) { datamin = data[j][i]; datamax = data[j][i]; areamin = area[j][i]; areamax = area[j][i]; haveMinMax = 1; } if(data[j][i] < datamin) datamin = data[j][i]; if(data[j][i] > datamax) datamax = data[j][i]; if(area[j][i] < areamin) areamin = area[j][i]; if(area[j][i] > areamax) areamax = area[j][i]; if(j < jmin) jmin = j; if(j > jmax) jmax = j; if(i < imin) imin = i; if(i > imax) imax = i; } else { data[j][i] = nan; area[j][i] = 0.; } } } imin += istart; jmin += jstart; imax += istart; jmax += jstart; if(debug >= 1) { printf("Data min = %-g\n", datamin); printf("Data max = %-g\n", datamax); printf("Area min = %-g\n", areamin); printf("Area max = %-g\n\n", areamax); printf("j min = %d\n", jmin); printf("j max = %d\n", jmax); printf("i min = %d\n", imin); printf("i max = %d\n", imax); } if(jmin > jmax || imin > imax) printError("All pixels are blank."); /********************************/ /* Create the output FITS files */ /********************************/ remove(output_file); remove(output_area_file); if(fits_create_file(&output.fptr, output_file, &status)) printFitsError(status); if(fits_create_file(&output_area.fptr, output_area_file, &status)) printFitsError(status); /*********************************************************/ /* Create the FITS image. All the required keywords are */ /* handled automatically. */ /*********************************************************/ if (fits_create_img(output.fptr, bitpix, naxis, output.naxes, &status)) printFitsError(status); if(debug >= 1) { printf("\nFITS data image created (not yet populated)\n"); fflush(stdout); } if (fits_create_img(output_area.fptr, bitpix, naxis, output_area.naxes, &status)) printFitsError(status); if(debug >= 1) { printf("FITS area image created (not yet populated)\n"); fflush(stdout); } /****************************************/ /* Set FITS header from a template file */ /****************************************/ if(fits_write_key_template(output.fptr, template_file, &status)) printFitsError(status); if(debug >= 1) { printf("Template keywords written to FITS data image\n"); fflush(stdout); } if(fits_write_key_template(output_area.fptr, template_file, &status)) printFitsError(status); if(debug >= 1) { printf("Template keywords written to FITS area image\n\n"); fflush(stdout); } /***************************/ /* Modify BITPIX to be -64 */ /***************************/ if(fits_update_key_lng(output.fptr, "BITPIX", -64, (char *)NULL, &status)) printFitsError(status); if(fits_update_key_lng(output_area.fptr, "BITPIX", -64, (char *)NULL, &status)) printFitsError(status); /***************************************************/ /* Update NAXIS, NAXIS1, NAXIS2, CRPIX1 and CRPIX2 */ /***************************************************/ if(fits_update_key_lng(output.fptr, "NAXIS", 2, (char *)NULL, &status)) printFitsError(status); if(fits_update_key_lng(output.fptr, "NAXIS1", imax-imin+1, (char *)NULL, &status)) printFitsError(status); if(fits_update_key_lng(output.fptr, "NAXIS2", jmax-jmin+1, (char *)NULL, &status)) printFitsError(status); if(fits_update_key_dbl(output.fptr, "CRPIX1", output.crpix1-imin, -14, (char *)NULL, &status)) printFitsError(status); if(fits_update_key_dbl(output.fptr, "CRPIX2", output.crpix2-jmin, -14, (char *)NULL, &status)) printFitsError(status); if(fits_update_key_lng(output_area.fptr, "NAXIS", 2, (char *)NULL, &status)) printFitsError(status); if(fits_update_key_lng(output_area.fptr, "NAXIS1", imax-imin+1, (char *)NULL, &status)) printFitsError(status); if(fits_update_key_lng(output_area.fptr, "NAXIS2", jmax-jmin+1, (char *)NULL, &status)) printFitsError(status); if(fits_update_key_dbl(output_area.fptr, "CRPIX1", output.crpix1-imin, -14, (char *)NULL, &status)) printFitsError(status); if(fits_update_key_dbl(output_area.fptr, "CRPIX2", output.crpix2-jmin, -14, (char *)NULL, &status)) printFitsError(status); if(debug >= 1) { printf("Template keywords BITPIX, CRPIX, and NAXIS updated\n"); fflush(stdout); } /************************/ /* Write the image data */ /************************/ fpixel[0] = 1; fpixel[1] = 1; nelements = imax - imin + 1; for(j=jmin; j<=jmax; ++j) { if (fits_write_pix(output.fptr, TDOUBLE, fpixel, nelements, (void *)(&data[j-jstart][imin-istart]), &status)) printFitsError(status); ++fpixel[1]; } free(data[0]); if(debug >= 1) { printf("Data written to FITS data image\n"); fflush(stdout); } /***********************/ /* Write the area data */ /***********************/ fpixel[0] = 1; fpixel[1] = 1; nelements = imax - imin + 1; for(j=jmin; j<=jmax; ++j) { if (fits_write_pix(output_area.fptr, TDOUBLE, fpixel, nelements, (void *)(&area[j-jstart][imin-istart]), &status)) printFitsError(status); ++fpixel[1]; } free(area[0]); if(debug >= 1) { printf("Data written to FITS area image\n\n"); fflush(stdout); } /***********************/ /* Close the FITS file */ /***********************/ if(fits_close_file(output.fptr, &status)) printFitsError(status); if(debug >= 1) { printf("FITS data image finalized\n"); fflush(stdout); } if(fits_close_file(output_area.fptr, &status)) printFitsError(status); if(debug >= 1) { printf("FITS area image finalized\n\n"); fflush(stdout); } if(debug >= 1) { time(&currtime); printf("Done (%.0f seconds total)\n", (double)(currtime - start)); fflush(stdout); } fprintf(fstatus, "[struct stat=\"OK\"]\n"); fflush(stdout); exit(0); }
void ConfigurationFindscholarships::readConfig(const std::string& filename) { path_root = readLine(filename, "PATH_ROOT"); path_templates = path_root + readLine(filename, "DIR_TEMPLATES"); path_production_root = path_root + readLine(filename, "DIR_PRODUCTION_ROOT"); path_database = path_root + readLine(filename, "DIR_DATABASE"); path_images = path_root + readLine(filename, "DIR_IMAGES"); path_expired = path_database + readLine(filename, "EXPIRED"); path_temp = path_root + readLine(filename, "DIR_TEMPORARY"); root_domain = readLine(filename, "ROOT_DOMAIN"); filename_input_links = readLine(filename, "INPUT_LINKS"); filename_input_fetched = readLine(filename, "INPUT_FETCHED"); filename_marker_dbworld = readLine(filename, "MARKER_DBWORLD"); filename_input_dbworld = readLine(filename, "INPUT_DBWORLD"); filename_html_scholarship_positions_gmail = readLine(filename, "HTML_SCHOLARSHIP_POSITIONS_GMAIL"); filename_input_scholarship_positions_gmail = readLine(filename, "INPUT_SCHOLARSHIP_POSITIONS_GMAIL"); filename_html_scholarship_links_gmail = readLine(filename, "HTML_SCHOLARSHIP_LINKS_GMAIL"); filename_input_scholarship_links_gmail = readLine(filename, "INPUT_SCHOLARSHIP_LINKS_GMAIL"); path_storages.reserve(TOTAL_STORAGES); path_storages.push_back(path_database + readLine(filename, "DB_UNDERGRAD")); // IDX_UNDERGRAD path_storages.push_back(path_database + readLine(filename, "DB_MASTER")); // IDX_MASTER path_storages.push_back(path_database + readLine(filename, "DB_PHD")); // IDX_PHD path_storages.push_back(path_database + readLine(filename, "DB_POSTDOC")); // IDX_POSTDOC path_storages.push_back(path_database + readLine(filename, "DB_ACADEMIC_JOB")); // IDX_ACADEMIC path_storages.push_back(path_database + readLine(filename, "DB_UNCLASSIFIED")); // IDX_UNCLASSIFIED path_storages.push_back(path_database + readLine(filename, "DB_HOMEPAGE")); // IDX_HOMEPAGE category_titles.push_back(readLine(filename, "TITLE_UNDERGRAD")); category_titles.push_back(readLine(filename, "TITLE_MASTER")); category_titles.push_back(readLine(filename, "TITLE_PHD")); category_titles.push_back(readLine(filename, "TITLE_POSTDOC")); category_titles.push_back(readLine(filename, "TITLE_ACADEMIC_JOB")); category_titles.push_back(readLine(filename, "TITLE_UNCLASSIFIED")); category_titles.push_back(readLine(filename, "TITLE_HOMEPAGE")); category_vec.push_back(readLine(filename, "CATEGORY_UNDERGRAD")); category_vec.push_back(readLine(filename, "CATEGORY_MASTER")); category_vec.push_back(readLine(filename, "CATEGORY_PHD")); category_vec.push_back(readLine(filename, "CATEGORY_POSTDOC")); category_vec.push_back(readLine(filename, "CATEGORY_ACADEMIC_JOB")); category_vec.push_back(readLine(filename, "CATEGORY_UNCLASSIFIED")); category_vec.push_back(readLine(filename, "CATEGORY_HOMEPAGE")); assert (path_storages.size() == TOTAL_STORAGES); header1_tpl = readLine(filename, "HEADER_PART1"); header2_tpl = readLine(filename, "HEADER_PART2"); header2_main_tpl = readLine(filename, "HEADER_MAIN_PART2"); body1_tpl = readLine(filename, "BODY_PART1"); body2_tpl = readLine(filename, "BODY_PART2"); body3_tpl = readLine(filename, "BODY_PART3"); category1_tpl = readLine(filename, "CATEGORY_PART1"); category2_tpl = readLine(filename, "CATEGORY_PART2"); category3_tpl = readLine(filename, "CATEGORY_PART3"); category4_tpl = readLine(filename, "CATEGORY_PART4"); readTemplate(header1_tpl, header_part1); readTemplate(header2_tpl, header_part2); readTemplate(header2_main_tpl, header_main_part2); readTemplate(body1_tpl, body_part1); readTemplate(body2_tpl, body_part2); readTemplate(body3_tpl, body_part3); readTemplate(category1_tpl, category1); readTemplate(category2_tpl, category2); readTemplate(category3_tpl, category3); readTemplate(category4_tpl, category4); }