// Writes a histogram to a file readable by gnuplot. void Histogram::write(string path) const { std::fstream fid(path, std::ios::out); double x(_x0 + 0.5*_dx); for (auto h=histogram.begin(); h!=histogram.end(); ++h, x+=_dx) { fid << x << "\t" << *h << "\n"; } }
size_t OnlineSession::updateRead(string filename, byte*& file, size_t bytesToAdd, double& diskTime){ this->filename = filename; fileID fid(filename); this->fid = fid; byte lowerFid[LOWERFID_SIZE]; this->fid.getLowerID(lowerFid); // printhex(lowerFid, LOWERFID_SIZE, "LOWER FID"); PRSubset prSubset(SIZE_MIN, filename); this->prSubset = prSubset; firstDAccess(filename, diskTime); b_index_t numBlocksAfterUpdate = (b_index_t)(ceil((double)(filesize+bytesToAdd)/(double)MAX_BLOCK_DATA_SIZE)); numBlocks = max(numBlocks, numBlocksAfterUpdate); if(numBlocks*BLOW_UP > SIZE_MIN){ secondDAccess(filename, diskTime); } else numBlocks = SIZE_MIN; file = new byte[filesize]; memset(file, 0, filesize); for(int i = 1; i < fileBlocks.size(); i++){ byte block[BLOCK_SIZE]; memset(block, 0, BLOCK_SIZE); fileBlocks[i].getDecrypted(block); memcpy(&file[(i-1)*MAX_BLOCK_DATA_SIZE], block, fileBlocks[i].getDataSize()); } return filesize; }
FunctionTacValue(TacFunctionPtr f) : function(f) { isFunction = true; IdentifierPtr fid(new Identifier); fid->id = Token(f->name, -1, -1); id = fid; }
QMessageFolderId::QMessageFolderId(const QString& id) : d_ptr(0) { QMailFolderId fid(QmfHelpers::stripIdentifierPrefix(id).toULongLong()); if (fid.isValid()) { d_ptr = new QMessageFolderIdPrivate; d_ptr->_id = fid; } }
void ServiceManagement::testMethod() { ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)\n"))); PeerMap map; UUIDPtr pid(UUID::generateUUID()); UUIDPtr pid2(UUID::generateUUID()); UUIDPtr fid(UUID::generateUUID()); UUIDPtr sid(UUID::generateUUID()); UUIDPtr iid1(UUID::generateUUID()); UUIDPtr iid2(UUID::generateUUID()); SAPInfoPtr meshSAP; SAPInfoPtr ftSAP; SAPInfoPtr discoverySAP; PeerInfoPtr peerPtr(new PeerInfoEx(pid,fid,meshSAP,discoverySAP,ftSAP)); map.addPeer(peerPtr); try{ PeerInfoPtr pi; map.getPeerInfo(pid,pi); }catch(PeerException& ex){ ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)ex=%s\n"),ex.toString().c_str())); } try{ PeerInfoPtr pi; map.getPeerInfo(pid2,pi); }catch(PeerException& ex){ ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)ex2=%s\n"),ex.toString().c_str())); } peerPtr->addServiceInstance(sid,iid1); ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)Output:\n%s\n"),peerPtr->toString().c_str())); list<UUIDPtr> l; peerPtr->getInstancesOfService(sid,l); ListHelper<UUIDPtr>::printSmartPtrList(l); ServiceInstanceInfoPtr i; peerPtr->getInstanceOfService(sid,l.front(),i); ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)=====%s\n"),i->toString().c_str())); //bool ret = peerPtr->removeService(sid); //ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)after remove = %d\n",ret); //delete l; CPPUNIT_ASSERT(true); }
void OnlineSession::updateWithInsecureAppend(string filename, byte*& file, double& diskTime){ this->filename = filename; fileID fid(filename); this->fid = fid; byte lowerFid[LOWERFID_SIZE]; this->fid.getLowerID(lowerFid); PRSubset prSubset(SIZE_MIN, filename); this->prSubset = prSubset; updateAccess(filename, diskTime); }
/*! * \example SerialExample/ex1.cpp * * A simple example of MINRES() usage without preconditioner. */ int main() { //(1) Define the size of the problem we want to solve int size(1000); //(2) Define the linear operator "op" we want to solve. SimpleOperator op(size); //(3) Generate a random linear system op.Randomize(0); //(3) Define the exact solution (at random) SimpleVector sol(size); sol.Randomize( 1 ); //(4) Define the "rhs" as "rhs = op*sol" SimpleVector rhs(size); op.Apply(sol, rhs); double rhsNorm( sqrt(InnerProduct(rhs,rhs)) ); std::cout << "|| rhs || = " << rhsNorm << "\n"; //(5) We don't use any preconditioner. Let prec be a null pointer. Preconditioner * prec = NULL; //(6) Use an identically zero initial guess SimpleVector x(size); x = 0; //(7) Set the minres parameters double shift(0); int max_iter(10000); double tol(1e-6); bool show(false); //(8) Solve the problem with minres MINRES(op, x, rhs, prec, shift, max_iter, tol, show); //(9) Compute the error || x_ex - x_minres ||_2 subtract(x, sol, x); double err2 = InnerProduct(x,x); std::cout<< "|| x_ex - x_n || = " << sqrt(err2) << "\n"; std::ofstream fid("ex3.m"); op.Print(fid); fid<< "rhs = ["; for(int i(0); i<size-1; ++i) fid<<rhs[i] <<"; "; fid<<rhs[size-1] <<"]; \n"; fid<<"[ x, istop, itn, rnorm, Arnorm, Anorm, Acond, ynorm ] = minres(Op, rhs, [], 0, true, false, 100, 1e-6);\n"; return 0; }
/****************************************************************************** TerSetFrameTextDist: Set the minimum distance to maintain between text and the frame border. ******************************************************************************/ BOOL WINAPI _export TerSetFrameTextDist(HWND hWnd, int ParaFID,int dist) { PTERWND w; if (NULL==(w=GetWindowPointer(hWnd))) return FALSE; // get the pointer to window data if (ParaFID<=0) ParaFID=fid(CurLine); if (ParaFID<=0 || ParaFID>=TotalParaFrames || !ParaFrame[ParaFID].InUse) return false; ParaFrame[ParaFID].DistFromText=dist; RequestPagination(w,true); return TRUE; }
void write_to_file(int nx, int ny, double* data) { { FILE* output = fopen("output.bin", "w"); fwrite(data, sizeof(double), nx * ny, output); fclose(output); } std::ofstream fid("output.bov"); fid << "TIME: 0.0" << std::endl; fid << "DATA_FILE: output.bin" << std::endl; fid << "DATA_SIZE: " << nx << " " << ny << " 1" << std::endl;; fid << "DATA_FORMAT: DOUBLE" << std::endl; fid << "VARIABLE: phi" << std::endl; fid << "DATA_ENDIAN: LITTLE" << std::endl; fid << "CENTERING: nodal" << std::endl; fid << "BRICK_SIZE: 1.0 1.0 1.0" << std::endl; }
unsigned long int MP_Var_Array_c<TYPE>::save_ui_to_text( const char* fName ) { //FILE *fid; ofstream fid(fName); unsigned long int i; //if ( (fid = fopen( fName, "w" )) == NULL ) { if(!fid.is_open()){ mp_error_msg( "MP_Var_Array_c::save(fName)", "Failed to open the file [%s] for writing.\n", fName ); return( 0 ); } for ( i = 0 ; i< nElem; i++) //fprintf (fid, "Iteration %lu Source [%lu]\n",i, elem[i]); fid << "Iteration " << i << " Source [" << elem[i] << "]\n"; //fclose( fid ); fid.close(); return( i ); }
void lemur::parse::KeyfileDocMgr::writeTOC() { if (_readOnly) return; string n = IDname + BT_TOC; ofstream toc(n.c_str()); toc << "FILE_LOOKUP " << IDname << BT_LOOKUP << endl; toc << "POS_LOOKUP " << IDname << BT_POSITIONS << endl; toc << "PARSE_MODE " << pm << endl; toc << "FILE_IDS " << IDname << BT_FID << endl; toc << "NUM_FILES " << sources.size() << endl; toc << "NUM_DOCS " << numdocs << endl; toc.close(); n = IDname + BT_FID; ofstream fid(n.c_str()); for (int i = 0; i < sources.size(); i++) { fid << i << " " << sources[i] << endl; } fid.close(); }
void onRenderRasterCompleted(const RenderData &renderData) override { TRasterP outputRaster = renderData.m_rasA; TRasterImageP img(outputRaster->clone()); img->setDpi(m_cameraDpi.x, m_cameraDpi.y); if (m_outputImage) m_outputImage->setImg(img); else if (m_outputLevel) { std::vector<std::string> ids; for (int i = 0; i < (int)renderData.m_frames.size(); i++) { TFrameId fid((int)(renderData.m_frames[i]) + 1); m_outputLevel->setFrame(fid, img); std::string id = m_outputLevel->getSimpleLevel()->getImageId(fid); ids.push_back(id); } img = TImageP(); for (int i = 0; i < (int)ids.size(); i++) TImageCache::instance()->compress(ids[i]); } }
// constructors LoHighCamera::LoHighCamera (Pvl &lab) : FramingCamera(lab) { // Get the Instrument label information needed to define the camera for this frame PvlGroup inst = lab.FindGroup ("Instrument",Pvl::Traverse); iString spacecraft = (string)inst["SpacecraftName"]; iString instId = (string)inst["InstrumentId"]; // Turn off the aberration corrections for the instrument position object InstrumentPosition()->SetAberrationCorrection("NONE"); // Get the camera characteristics SetFocalLength (); SetPixelPitch (); // Get the start time in et string stime = inst["StartTime"]; double time; str2et_c(stime.c_str(),&time); // Setup focal plane map LoCameraFiducialMap fid( inst, NaifIkCode()); // Setup detector map new CameraDetectorMap(this); // Setup focalplane map CameraFocalPlaneMap *focalMap = new CameraFocalPlaneMap(this,NaifIkCode()); // Try (0.,0.) focalMap->SetDetectorOrigin(0.0,0.0); // Setup distortion map LoHighDistortionMap *distortionMap = new LoHighDistortionMap(this); distortionMap->SetDistortion(NaifIkCode()); // Setup the ground and sky map new CameraGroundMap(this); new CameraSkyMap(this); SetEphemerisTime(time); LoadCache(); }
void TXshSoundTextColumn::createSoundTextLevel(int row, QList<QString> textList) { TXshSoundTextLevel *level = new TXshSoundTextLevel(); level->setType(SND_TXT_XSHLEVEL); int i = 0; TXshCell cell; for (i; i < textList.size(); i++, row++) { QString str = textList.at(i); QString precStr = (i > 0) ? level->getFrameText(i - 1) : QString(); if (str == QString("<none>")) { if (i > 0) { setCell(row, cell); continue; } else str = QString(); } level->setFrameText(i, str); TFrameId fid(i + 1); cell = TXshCell(level, fid); setCell(row, cell); } }
QScriptValue foo(QScriptContext *ctx, QScriptEngine *eng) { int r = ctx->argument(0).toInteger(); int c = ctx->argument(1).toInteger(); QScriptValue levelArg = ctx->argument(2); ScriptWrapper::Level *level = dynamic_cast<ScriptWrapper::Level *>(levelArg.toQObject()); if (level) { TXshSimpleLevel *sl = level->getLevel(); if (!sl) return QScriptValue(0); TFrameId fid(1); if (!sl->isFid(fid)) sl->setFrame(fid, sl->createEmptyFrame()); ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene(); scene->getXsheet()->setCell(r, c, TXshCell(sl, fid)); TApp::instance()->getCurrentXsheet()->notifyXsheetChanged(); } return QScriptValue(1); }
bool CSmartFactory<FunctionIdEnum, MessageTypeEnum, StructIdEnum>::attachSchema(NsSmartDeviceLink::NsSmartObjects::SmartObject &object) { if(false == object.keyExists(strings::S_PARAMS)) return false; if(false == object[strings::S_PARAMS].keyExists(strings::S_MESSAGE_TYPE)) return false; if(false == object[strings::S_PARAMS].keyExists(strings::S_FUNCTION_ID)) return false; MessageTypeEnum msgtype((MessageTypeEnum)(int)object[strings::S_PARAMS][strings::S_MESSAGE_TYPE]); FunctionIdEnum fid((FunctionIdEnum)(int)object[strings::S_PARAMS][strings::S_FUNCTION_ID]); SmartSchemaKey<FunctionIdEnum, MessageTypeEnum> key(fid, msgtype); typename FuncionsSchemesMap::iterator schemaIterator = functions_schemes_.find(key); if(schemaIterator == functions_schemes_.end()) { // Schema was not found return false; } object.setSchema(schemaIterator->second); schemaIterator->second.applySchema(object); return true; }
void TarWriter::writeFile(String path, FileStatus *status) { Ref<StringList> headerFields = StringList::create(); off_t contentSize = status->size(); if (status->type() != File::Regular) contentSize = 0; if (status->type() == File::Directory) { if (path->count() > 0) { if (path->at(path->count() - 1) != '/') path = path + "/"; } } String pathField(99, '\0'); if (status == longPathStatus_ || status == longLinkStatus_) *pathField = *String("././@LongLink"); else *pathField = *path; headerFields->append(pathField); headerFields->append(zero_); headerFields->append(oct(status->mode(), 7)); headerFields->append(zero_); headerFields->append(oct(status->ownerId(), 7)); headerFields->append(zero_); headerFields->append(oct(status->groupId(), 7)); headerFields->append(zero_); if (status == longPathStatus_ || status == longLinkStatus_) headerFields->append(oct(path->count() + 1, 11)); else headerFields->append(oct(contentSize, 11)); headerFields->append(zero_); headerFields->append(oct(status->st_mtime, 11)); headerFields->append(zero_); String checksumField(6, '0'); headerFields->append(checksumField); headerFields->append(String("\0 ", 2)); String typeField, linkTarget; if (status == longLinkStatus_ ) typeField = "K"; else if (status == longPathStatus_) typeField = "L"; else { if (status->type() == File::Regular) ; else if (status->type() == File::Directory) typeField = "5"; else if (status->type() == File::Symlink) typeField = "2"; else if (status->type() == File::CharDevice) typeField = "3"; else if (status->type() == File::BlockDevice) typeField = "4"; else if (status->type() == File::Fifo) typeField = "6"; if (status->numberOfHardLinks() > 1) { FileId fid(status); if (hardLinks_->lookup(fid, &linkTarget)) typeField = "1"; else hardLinks_->insert(fid, path); } else if (status->type() == File::Symlink) { linkTarget = File::readlink(path); } if (typeField == "") typeField = "0"; if (typeField != "0") contentSize = 0; } headerFields->append(typeField); String linkField(99, '\0'); *linkField = *linkTarget; headerFields->append(linkField); headerFields->append(zero_); String gnuMagicField("ustar "); headerFields->append(gnuMagicField); headerFields->append(zero_); String userField(31, '\0'); *userField = *User::lookup(status->ownerId())->name(); headerFields->append(userField); headerFields->append(zero_); String groupField(31, '\0'); *groupField = *Group::lookup(status->groupId())->name(); headerFields->append(groupField); headerFields->append(zero_); if (status != longPathStatus_ && status != longLinkStatus_) { if (path->count() > pathField->count()) writeFile(path, longPathStatus_); if (linkTarget->count() > linkField->count()) writeFile(linkTarget, longLinkStatus_); } String header = headerFields->join(); FLUX_ASSERT(header->count() == 329); unsigned checksum = tarHeaderSum(header); *checksumField = *oct(checksum, 6); header = headerFields->join(); sink_->write(header); writePadding(header->count()); if (status == longPathStatus_ || status == longLinkStatus_) { sink_->write(path); sink_->write(zero_); writePadding(path->count() + 1); } else if (contentSize > 0) { File::open(path)->transfer(contentSize, sink_); writePadding(contentSize); } }
void test_Polygon(int &failed_test_count, int &disabled_test_count) { const std::string GROUP = "Polygon"; const double EQT = 1.0e-15; //----------------------------------------------------------------------------- { Test t(GROUP, "set_get_my_zone", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Face *f = new Polygon; size_t expected = 7; f->set_my_zone(expected); size_t actual = f->get_my_zone(); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "set_get_my_id", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Face *f = new Polygon; short int expected = 7; f->set_my_id(expected); short int actual = f->get_my_id(); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "ctor_check_my_zone", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { size_t mz = 6; short int mi = 9; Face *f = new Polygon(mz, mi); size_t expected = mz; size_t actual = f->get_my_zone(); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "ctor_check_my_id", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { size_t mz = 6; short int mi = 9; Face *f = new Polygon(mz, mi); short int expected = mi; short int actual = f->get_my_id(); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "size0", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Face *f = new Polygon; size_t expected = 0; size_t actual = f->size(); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "size", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Vector3d v(1.0, 2.0, 3.0); Node n0(3, v); Node n1(5, v, v); Face *f = new Polygon; f->add_node(n0.geti()); f->add_node(n1.geti()); size_t expected = 2; size_t actual = f->size(); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "is_curved", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Grid g; Face *f = new Polygon; Vector3d v(1.0, 2.0, 3.0); Node n0(3, v); f->add_node(n0.geti()); f->add_node(n0.geti()); f->add_node(n0.geti()); bool expected = false; bool actual = f->is_curved(g); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "is_flat", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Grid g; Face *f = new Polygon; Vector3d v(1.0, 2.0, 3.0); Node n0(3, v); f->add_node(n0.geti()); f->add_node(n0.geti()); f->add_node(n0.geti()); bool expected = true; bool actual = f->is_flat(g); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "get_node_id", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Vector3d v(1.0, 2.0, 3.0); Node n0(3, v); Node n1(5, v, v); Face *f = new Polygon; f->add_node(n0.geti()); f->add_node(n1.geti()); size_t expected = 5; size_t actual = f->get_node(1); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "get_node_id_out_of_range", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Vector3d v(1.0, 2.0, 3.0); Node n0(3, v); Node n1(5, v, v); Face *f = new Polygon; f->add_node(n0.geti()); f->add_node(n1.geti()); std::string expected = "out of range exception"; std::string actual = UNCAUGHT_EXCEPTION; try { size_t n = f->get_node(2); std::cout << n; } catch (const std::out_of_range &oor) { actual = "out of range exception"; } failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "abs_diff", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Face *f = new Polygon(3, 1); Face *g = new Polygon(4, 5); f->add_node(6); g->add_node(2); g->add_node(9); g->add_node(4); double expected = 37.0; double actual = f->abs_diff(*g); failed_test_count += t.check_equal_real_num(expected, actual, EQT); delete f; delete g; } } //----------------------------------------------------------------------------- { Test t(GROUP, "to_string", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Face *f = new Polygon(3, 1); f->add_node(98765); f->add_node(98766); f->add_node(98767); f->add_node(98768); f->add_node(98769); std::string expected = "Polygon\n 5\n"; expected += " 3 1\n"; expected += " 98765 98766 98767 98768 98769"; expected += "\n neighbors 0"; std::string actual = f->to_string(); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "ctor0", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Face *expected = new Polygon(0, -2); Face *actual = new Polygon; failed_test_count += t.check_equal_real_obj(*expected, *actual, EQT); delete expected; delete actual; } } //----------------------------------------------------------------------------- { Test t(GROUP, "assignment", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Face *expected = new Polygon(4, 5); expected->add_node(2); expected->add_node(9); expected->add_node(4); Face *actual = new Polygon; *actual = *expected; failed_test_count += t.check_equal_real_obj(*expected, *actual, EQT); delete expected; delete actual; } } //----------------------------------------------------------------------------- { Test t(GROUP, "add_get_neighboring_zone", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Face *f = new Polygon(3, 1); f->add_neighbor(2, 4); f->add_neighbor(9, 5); size_t expected = 9; size_t actual = f->get_neighbor(1).my_zone; failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "add_get_neighboring_Polygon", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Face *f = new Polygon(3, 1); f->add_neighbor(2, 4); f->add_neighbor(9, 5); short int expected = 5; short int actual = f->get_neighbor(1).my_id; failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "neighbor_count", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Face *f = new Polygon(3, 1); f->add_neighbor(2, 4); f->add_neighbor(9, 5); size_t expected = 2; size_t actual = f->num_nbr(); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "add_get_neighbor_out_of_range", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { Face *f = new Polygon(3, 1); f->add_neighbor(2, 4); f->add_neighbor(9, 5); std::string expected = "out of range exception"; std::string actual = UNCAUGHT_EXCEPTION; try { FaceID n = f->get_neighbor(5); std::cout << n.my_zone << " " << n.my_id; } catch (const std::out_of_range &oor) { actual = "out of range exception"; } failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "area2_normal_triangle", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "triangle.inc" Vector3d expected(4.0, 3.0, 12.0); Vector3d actual = f->area2_normal_center(g, v); failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "area2_normal_rectangle", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" Vector3d expected(0.0, 0.0, 12.0); Vector3d actual = f->area2_normal_center(g, v); failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "area2_normal_trapezoid", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "trapezoid.inc" Vector3d expected(0.0, 0.0, 8.0); Vector3d actual = f->area2_normal_center(g, v); failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "area2_normal_hexagon", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "hexagon.inc" Vector3d expected = Vector3d(0.0, 0.0, -6.0*r*s); Vector3d actual = f->area2_normal_center(g, v); failed_test_count += t.check_equal_real_obj(expected, actual, 10*EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "center_triangle", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "triangle.inc" Vector3d expected(1.0, 4.0/3.0, 1.0/3.0); Vector3d actual; f->area2_normal_center(g, actual); failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "center_rectangle", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" Vector3d expected(2.0, 2.5, 5.0); Vector3d actual; f->area2_normal_center(g, actual); failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "center_trapezoid", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "trapezoid.inc" Vector3d expected(13.0/12.0, 5.0/6.0, 0.0); Vector3d actual; f->area2_normal_center(g, actual); failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "center_hexagon", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "hexagon.inc" Vector3d expected = center; Vector3d actual; f->area2_normal_center(g, actual); failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "normal_triangle", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "triangle.inc" Vector3d expected(4.0/13.0, 3.0/13.0, 12.0/13.0); Vector3d actual = f->normal(g); failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "normal_rectangle", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" Vector3d expected(0.0, 0.0, 1.0); Vector3d actual = f->normal(g); failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "area_triangle", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "triangle.inc" double expected = 6.5; double actual = f->area(g); failed_test_count += t.check_equal_real_num(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "area_rectangle", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" double expected = 6.0; double actual = f->area(g); failed_test_count += t.check_equal_real_num(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "signed_distance_triangle", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "triangle.inc" Vector3d c; v = Vector3d(1.0, 4.0/3.0, 1.0/3.0) + f->area2_normal_center(g, c)/5; double expected = 2.6; double actual = f->distance(g, v); failed_test_count += t.check_equal_real_num(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "signed_distance_rectangle", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" v = Vector3d(7.0, 6.0, -4.0); double expected = -9.0; double actual = f->distance(g, v); failed_test_count += t.check_equal_real_num(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "subpoint_triangle", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "triangle.inc" Vector3d expected = Vector3d(1.0, 4.0/3.0, 1.0/3.0); Vector3d c; v = expected + f->area2_normal_center(g, c)/5; Vector3d actual = f->subpoint(g, v); failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "subpoint_rectangle", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" v = Vector3d(7.0, 6.0, -4.0); Vector3d expected = Vector3d(7.0, 6.0, 5.0); Vector3d actual = f->subpoint(g, v); failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_has_point_above", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "triangle.inc" Vector3d c; v = Vector3d(1.0, 4.0/3.0, 1.0/3.0) + f->area2_normal_center(g, c)/5; bool expected = true; bool actual = f->has_above(g, v); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "rectangle_has_point_above", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" v = Vector3d(7.0, 6.0, -4.0); bool expected = false; bool actual = f->has_above(g, v); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_has_point_below", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "triangle.inc" Vector3d c; v = Vector3d(1.0, 4.0/3.0, 1.0/3.0) + f->area2_normal_center(g, c)/5; bool expected = false; bool actual = f->has_below(g, v); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "rectangle_has_point_below", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" v = Vector3d(7.0, 6.0, -4.0); bool expected = true; bool actual = f->has_below(g, v); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_contains_point", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "triangle.inc" v = Vector3d(1.0, 4.0/3.0, 1.0/3.0); bool expected = true; bool actual = f->contains(g, v); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "rectangle_contains_point", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" v = Vector3d(2.0, 3.0, 5.0); bool expected = true; bool actual = f->contains(g, v); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "rectangle_misses_point", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" v = Vector3d(7.0, 6.0, 5.0); bool expected = false; bool actual = f->contains(g, v); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "rectangle_first_edge_contains_point", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" v = Vector3d(2.0, 1.0, 5.0); bool expected = true; bool actual = f->contains(g, v); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "rectangle_first_edge_misses_point", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" v = Vector3d(4.0, 1.0, 5.0); bool expected = false; bool actual = f->contains(g, v); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "rectangle_another_edge_contains_point", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" v = Vector3d(2.0, 4.0, 5.0); bool expected = true; bool actual = f->contains(g, v); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "rectangle_another_edge_misses_point", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "rectangle.inc" v = Vector3d(4.0, 4.0, 5.0); bool expected = false; bool actual = f->contains(g, v); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_distance", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "triangle.inc" Vector3d r(0.0, 0.0, 0.0); v = Vector3d(1.0, 4.0/3.0, 1.0/3.0); Vector3d w; double expected = 1.0; double actual = f->intercept(g, r, v, EQT, fid).t; failed_test_count += t.check_equal_real_num(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_point", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "triangle.inc" Vector3d r(0.0, 0.0, 0.0); v = Vector3d(1.0, 4.0/3.0, 1.0/3.0); Vector3d expected = v; Vector3d actual = f->intercept(g, r, v, EQT, fid).w; failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_face", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "triangle.inc" Vector3d r(0.0, 0.0, 0.0); v = Vector3d(1.0, 4.0/3.0, 1.0/3.0); FaceID expected = FaceID(2, 1); FaceID actual = f->intercept(g, r, v, EQT, fid).fid; failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_found", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "triangle.inc" Vector3d r(0.0, 0.0, 0.0); v = Vector3d(1.0, 4.0/3.0, 1.0/3.0); bool expected = true; bool actual = f->intercept(g, r, v, EQT, fid).is_found; failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_found_same_face", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(2, 1); // difference from triangle_intercept_found #include "triangle.inc" Vector3d r(0.0, 0.0, 0.0); v = Vector3d(1.0, 4.0/3.0, 1.0/3.0); bool expected = false; // difference from triangle_intercept_found bool actual = f->intercept(g, r, v, EQT, fid).is_found; failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_distance_negative", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "triangle.inc" Vector3d r(0.0, 0.0, 0.0); v = Vector3d(-1.0, -4.0/3.0, -1.0/3.0); Vector3d w; double expected = -1.0; double actual = f->intercept(g, r, v, EQT, fid).t; failed_test_count += t.check_equal_real_num(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_point_negative", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "triangle.inc" Vector3d r(0.0, 0.0, 0.0); v = Vector3d(-1.0, -4.0/3.0, -1.0/3.0); Vector3d expected = -v; Vector3d actual = f->intercept(g, r, v, EQT, fid).w; failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_found_negative", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "triangle.inc" Vector3d r(0.0, 0.0, 0.0); v = Vector3d(-1.0, -4.0/3.0, -1.0/3.0); bool expected = false; bool actual = f->intercept(g, r, v, EQT, fid).is_found; failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_distance_0", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "triangle.inc" Vector3d r(1.0, 4.0/3.0, 1.0/3.0); v = Vector3d(-1.0, -4.0/3.0, -1.0/3.0); Vector3d w; double expected = 0.0; double actual = f->intercept(g, r, v, EQT, fid).t; failed_test_count += t.check_equal_real_num(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_point_0", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "triangle.inc" Vector3d r(1.0, 4.0/3.0, 1.0/3.0); v = Vector3d(-1.0, -4.0/3.0, -1.0/3.0); Vector3d expected = -v; Vector3d actual = f->intercept(g, r, v, EQT, fid).w; failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_found_0", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "triangle.inc" Vector3d r(1.0, 4.0/3.0, 1.0/3.0); v = Vector3d(-1.0, -4.0/3.0, -1.0/3.0); bool expected = false; bool actual = f->intercept(g, r, v, EQT, fid).is_found; failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_distance_parallel", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "triangle.inc" Vector3d r(0.0, 0.0, 0.0); v = Vector3d(-3.0, 0.0, 1.0); // parallel to the plane Vector3d w; double expected = -Vector3d::get_big(); double actual = f->intercept(g, r, v, EQT, fid).t; failed_test_count += t.check_equal_real_num(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_point_parallel", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "triangle.inc" Vector3d r(0.0, 0.0, 0.0); v = Vector3d(-3.0, 0.0, 1.0); // parallel to the plane double big = -Vector3d::get_big(); Vector3d expected(big, big, big); Vector3d actual = f->intercept(g, r, v, EQT, fid).w; failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "triangle_intercept_found_parallel", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "triangle.inc" Vector3d r(0.0, 0.0, 0.0); v = Vector3d(-3.0, 0.0, 1.0); // parallel to the plane bool expected = false; bool actual = f->intercept(g, r, v, EQT, fid).is_found; failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "rectangle_contains_intercept", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "rectangle.inc" Vector3d r(2.0, 2.0, 0.0); v = Vector3d(0.0, 0.0, 1.0); bool expected = true; bool actual = f->intercept(g, r, v, EQT, fid).is_found; failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "rectangle_does_not_contain_intercept", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { FaceID fid(9, 8); #include "rectangle.inc" Vector3d r(-2.0, -2.0, 0.0); v = Vector3d(0.0, 0.0, 1.0); bool expected = false; bool actual = f->intercept(g, r, v, EQT, fid).is_found; failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "velocity_triangle", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "velocity_triangle.inc" Vector3d c(1.0, 4.0/3.0, 1.0/3.0); Vector3d expected(4.3677256019137740, 1.4401036616521570, 0.8384202999809531); Vector3d actual = f->velocity(g, c); failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "velocity_triangle_at_x", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "velocity_triangle.inc" Vector3d c(3.0, 0.0, 0.0); Vector3d expected(4.0, -3.0, 2.0); Vector3d actual = f->velocity(g, c); failed_test_count += t.check_equal_real_obj(expected, actual, EQT); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "clear_get_size", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "velocity_triangle.inc" f->clear(); size_t expected = 0; size_t actual = f->size(); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "clear_get_Node", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "velocity_triangle.inc" f->clear(); std::string expected("out of range exception"); std::string actual = UNCAUGHT_EXCEPTION; try { f->get_node(0); } catch (const std::out_of_range &oor) { actual = "out of range exception"; } failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "clear_num_nbr", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "velocity_triangle.inc" f->clear(); size_t expected = 0; size_t actual = f->num_nbr(); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "clear_get_Neighbor", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "velocity_triangle.inc" f->clear(); std::string expected("out of range exception"); std::string actual = UNCAUGHT_EXCEPTION; try { f->get_neighbor(0); } catch (const std::out_of_range &oor) { actual = "out of range exception"; } failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "clear_get_my_zone", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "velocity_triangle.inc" f->clear(); size_t expected = 0; size_t actual = f->get_my_zone(); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "clear_get_my_id", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { #include "velocity_triangle.inc" f->clear(); short int expected = -2; short int actual = f->get_my_id(); failed_test_count += t.check_equal(expected, actual); delete f; } } //----------------------------------------------------------------------------- { Test t(GROUP, "load_Hydro1_Mesh0_1st_Polygon", "fast"); check_to_disable_test(t, disabled_test_count); if (t.is_enabled()) { std::string path(cnst::PATH + "UniTest/Hydro1/"); std::string tlabel("0"); std::string fname = path + "mesh_" + tlabel + ".txt"; std::ifstream infile(fname.c_str()); utils::find_line(infile, "Polygon"); Polygon f(infile); infile.close(); infile.clear(); std::string expected("Polygon\n 4\n 0 -1\n"); expected += " 0 1 5 4\n"; expected += " neighbors 1\n 1 0"; std::string actual = f.to_string(); failed_test_count += t.check_equal(expected, actual); } } //----------------------------------------------------------------------------- }
int QgsTransectSample::createSample( QProgressDialog* pd ) { Q_UNUSED( pd ); if ( !mStrataLayer || !mStrataLayer->isValid() ) { return 1; } if ( !mBaselineLayer || !mBaselineLayer->isValid() ) { return 2; } //stratum id is not necessarily an integer QVariant::Type stratumIdType = QVariant::Int; if ( !mStrataIdAttribute.isEmpty() ) { stratumIdType = mStrataLayer->pendingFields().field( mStrataIdAttribute ).type(); } //create vector file writers for output QgsFields outputPointFields; outputPointFields.append( QgsField( "id", stratumIdType ) ); outputPointFields.append( QgsField( "station_id", QVariant::Int ) ); outputPointFields.append( QgsField( "stratum_id", stratumIdType ) ); outputPointFields.append( QgsField( "station_code", QVariant::String ) ); outputPointFields.append( QgsField( "start_lat", QVariant::Double ) ); outputPointFields.append( QgsField( "start_long", QVariant::Double ) ); QgsVectorFileWriter outputPointWriter( mOutputPointLayer, "utf-8", outputPointFields, QGis::WKBPoint, &( mStrataLayer->crs() ) ); if ( outputPointWriter.hasError() != QgsVectorFileWriter::NoError ) { return 3; } outputPointFields.append( QgsField( "bearing", QVariant::Double ) ); //add bearing attribute for lines QgsVectorFileWriter outputLineWriter( mOutputLineLayer, "utf-8", outputPointFields, QGis::WKBLineString, &( mStrataLayer->crs() ) ); if ( outputLineWriter.hasError() != QgsVectorFileWriter::NoError ) { return 4; } QgsFields usedBaselineFields; usedBaselineFields.append( QgsField( "stratum_id", stratumIdType ) ); usedBaselineFields.append( QgsField( "ok", QVariant::String ) ); QgsVectorFileWriter usedBaselineWriter( mUsedBaselineLayer, "utf-8", usedBaselineFields, QGis::WKBLineString, &( mStrataLayer->crs() ) ); if ( usedBaselineWriter.hasError() != QgsVectorFileWriter::NoError ) { return 5; } //debug: write clipped buffer bounds with stratum id to same directory as out_point QFileInfo outputPointInfo( mOutputPointLayer ); QString bufferClipLineOutput = outputPointInfo.absolutePath() + "/out_buffer_clip_line.shp"; QgsFields bufferClipLineFields; bufferClipLineFields.append( QgsField( "id", stratumIdType ) ); QgsVectorFileWriter bufferClipLineWriter( bufferClipLineOutput, "utf-8", bufferClipLineFields, QGis::WKBLineString, &( mStrataLayer->crs() ) ); //configure distanceArea depending on minDistance units and output CRS QgsDistanceArea distanceArea; distanceArea.setSourceCrs( mStrataLayer->crs().srsid() ); if ( mMinDistanceUnits == Meters ) { distanceArea.setEllipsoidalMode( true ); } else { distanceArea.setEllipsoidalMode( false ); } //possibility to transform output points to lat/long QgsCoordinateTransform toLatLongTransform( mStrataLayer->crs(), QgsCoordinateReferenceSystem( 4326, QgsCoordinateReferenceSystem::EpsgCrsId ) ); //init random number generator mt_srand( QTime::currentTime().msec() ); QgsFeatureRequest fr; fr.setSubsetOfAttributes( QStringList() << mStrataIdAttribute << mMinDistanceAttribute << mNPointsAttribute, mStrataLayer->pendingFields() ); QgsFeatureIterator strataIt = mStrataLayer->getFeatures( fr ); QgsFeature fet; int nTotalTransects = 0; int nFeatures = 0; if ( pd ) { pd->setMaximum( mStrataLayer->featureCount() ); } while ( strataIt.nextFeature( fet ) ) { if ( pd ) { pd->setValue( nFeatures ); } if ( pd && pd->wasCanceled() ) { break; } if ( !fet.constGeometry() ) { continue; } const QgsGeometry* strataGeom = fet.constGeometry(); //find baseline for strata QVariant strataId = fet.attribute( mStrataIdAttribute ); QgsGeometry* baselineGeom = findBaselineGeometry( strataId.isValid() ? strataId : -1 ); if ( !baselineGeom ) { continue; } double minDistance = fet.attribute( mMinDistanceAttribute ).toDouble(); double minDistanceLayerUnits = minDistance; //if minDistance is in meters and the data in degrees, we need to apply a rough conversion for the buffer distance double bufferDist = bufferDistance( minDistance ); if ( mMinDistanceUnits == Meters && mStrataLayer->crs().mapUnits() == QGis::DecimalDegrees ) { minDistanceLayerUnits = minDistance / 111319.9; } QgsGeometry* clippedBaseline = strataGeom->intersection( baselineGeom ); if ( !clippedBaseline || clippedBaseline->wkbType() == QGis::WKBUnknown ) { delete clippedBaseline; continue; } QgsGeometry* bufferLineClipped = clipBufferLine( strataGeom, clippedBaseline, bufferDist ); if ( !bufferLineClipped ) { delete clippedBaseline; continue; } //save clipped baseline to file QgsFeature blFeature; blFeature.setGeometry( *clippedBaseline ); blFeature.setAttribute( "stratum_id", strataId ); blFeature.setAttribute( "ok", "f" ); usedBaselineWriter.addFeature( blFeature ); //start loop to create random points along the baseline int nTransects = fet.attribute( mNPointsAttribute ).toInt(); int nCreatedTransects = 0; int nIterations = 0; int nMaxIterations = nTransects * 50; QgsSpatialIndex sIndex; //to check minimum distance QMap< QgsFeatureId, QgsGeometry* > lineFeatureMap; while ( nCreatedTransects < nTransects && nIterations < nMaxIterations ) { double randomPosition = (( double )mt_rand() / MD_RAND_MAX ) * clippedBaseline->length(); QgsGeometry* samplePoint = clippedBaseline->interpolate( randomPosition ); ++nIterations; if ( !samplePoint ) { continue; } QgsPoint sampleQgsPoint = samplePoint->asPoint(); QgsPoint latLongSamplePoint = toLatLongTransform.transform( sampleQgsPoint ); QgsFeature samplePointFeature; samplePointFeature.setGeometry( samplePoint ); samplePointFeature.setAttribute( "id", nTotalTransects + 1 ); samplePointFeature.setAttribute( "station_id", nCreatedTransects + 1 ); samplePointFeature.setAttribute( "stratum_id", strataId ); samplePointFeature.setAttribute( "station_code", strataId.toString() + "_" + QString::number( nCreatedTransects + 1 ) ); samplePointFeature.setAttribute( "start_lat", latLongSamplePoint.y() ); samplePointFeature.setAttribute( "start_long", latLongSamplePoint.x() ); //find closest point on clipped buffer line QgsPoint minDistPoint; int afterVertex; if ( bufferLineClipped->closestSegmentWithContext( sampleQgsPoint, minDistPoint, afterVertex ) < 0 ) { continue; } //bearing between sample point and min dist point (transect direction) double bearing = distanceArea.bearing( sampleQgsPoint, minDistPoint ) / M_PI * 180.0; QgsPolyline sampleLinePolyline; QgsPoint ptFarAway( sampleQgsPoint.x() + ( minDistPoint.x() - sampleQgsPoint.x() ) * 1000000, sampleQgsPoint.y() + ( minDistPoint.y() - sampleQgsPoint.y() ) * 1000000 ); QgsPolyline lineFarAway; lineFarAway << sampleQgsPoint << ptFarAway; QgsGeometry* lineFarAwayGeom = QgsGeometry::fromPolyline( lineFarAway ); QgsGeometry* lineClipStratum = lineFarAwayGeom->intersection( strataGeom ); if ( !lineClipStratum ) { delete lineFarAwayGeom; delete lineClipStratum; continue; } //cancel if distance between sample point and line is too large (line does not start at point if ( lineClipStratum->distance( *samplePoint ) > 0.000001 ) { delete lineFarAwayGeom; delete lineClipStratum; continue; } //if lineClipStratum is a multiline, take the part line closest to sampleQgsPoint if ( lineClipStratum->wkbType() == QGis::WKBMultiLineString || lineClipStratum->wkbType() == QGis::WKBMultiLineString25D ) { QgsGeometry* singleLine = closestMultilineElement( sampleQgsPoint, lineClipStratum ); if ( singleLine ) { delete lineClipStratum; lineClipStratum = singleLine; } } //cancel if length of lineClipStratum is too small double transectLength = distanceArea.measure( lineClipStratum ); if ( transectLength < mMinTransectLength ) { delete lineFarAwayGeom; delete lineClipStratum; continue; } //search closest existing profile. Cancel if dist < minDist if ( otherTransectWithinDistance( lineClipStratum, minDistanceLayerUnits, minDistance, sIndex, lineFeatureMap, distanceArea ) ) { delete lineFarAwayGeom; delete lineClipStratum; continue; } QgsFeatureId fid( nCreatedTransects ); QgsFeature sampleLineFeature( fid ); sampleLineFeature.setGeometry( lineClipStratum ); sampleLineFeature.setAttribute( "id", nTotalTransects + 1 ); sampleLineFeature.setAttribute( "station_id", nCreatedTransects + 1 ); sampleLineFeature.setAttribute( "stratum_id", strataId ); sampleLineFeature.setAttribute( "station_code", strataId.toString() + "_" + QString::number( nCreatedTransects + 1 ) ); sampleLineFeature.setAttribute( "start_lat", latLongSamplePoint.y() ); sampleLineFeature.setAttribute( "start_long", latLongSamplePoint.x() ); sampleLineFeature.setAttribute( "bearing", bearing ); outputLineWriter.addFeature( sampleLineFeature ); //add point to file writer here. //It can only be written if the corresponding transect has been as well outputPointWriter.addFeature( samplePointFeature ); sIndex.insertFeature( sampleLineFeature ); Q_NOWARN_DEPRECATED_PUSH lineFeatureMap.insert( fid, sampleLineFeature.geometryAndOwnership() ); Q_NOWARN_DEPRECATED_POP delete lineFarAwayGeom; ++nTotalTransects; ++nCreatedTransects; } delete clippedBaseline; QgsFeature bufferClipFeature; bufferClipFeature.setGeometry( bufferLineClipped ); bufferClipFeature.setAttribute( "id", strataId ); bufferClipLineWriter.addFeature( bufferClipFeature ); //delete bufferLineClipped; //delete all line geometries in spatial index QMap< QgsFeatureId, QgsGeometry* >::iterator featureMapIt = lineFeatureMap.begin(); for ( ; featureMapIt != lineFeatureMap.end(); ++featureMapIt ) { delete( featureMapIt.value() ); } lineFeatureMap.clear(); delete baselineGeom; ++nFeatures; } if ( pd ) { pd->setValue( mStrataLayer->featureCount() ); } return 0; }
// Reads a LAMMPS input file. void LAMMPS_Data::read_data(string path) { fstream fid(path); if (!fid) { cout << "Error opening output file " << path << "!\n"; } int section=0; while (fid) { auto line = split(read_line(fid)); if (line.empty()) continue; else if (line[0]=="Masses") section=1; else if (line[0]=="Pair") section=2; else if (line[0]=="Bond") section=3; else if (line[0]=="Angle") section=4; else if (line[0]=="Dihedral") section=5; else if (line[0]=="Atoms") section=6; else if (line[0]=="Bonds") section=7; else if (line[0]=="Angles") section=8; else if (line[0]=="Dihedrals") section=9; switch (section) { case 1: if (line.size()==2) { //_system.atom_types.push_back(str2u32(line[0])); //_system.masses.push_back(str2dbl(line[1])); } break; case 6: Atom newatom; if (line.size() >= 6) { newatom.molecule = str2u32(line[1]); newatom.type = str2u32(line[2]); _system.atoms.push_back(newatom); } break; case 7: if (_system.connect.empty()) { _system.connect.assign(_system.atoms.size(), vector<int>(0)); } if (line.size()==4) { Bond newbond; //newbond.id = str2u32(line[0]); //newbond.type = str2u32(line[1]); newbond.atom1 = str2u32(line[2])-1; newbond.atom2 = str2u32(line[3])-1; //_system.bonds.push_back(newbond); _system.connect[newbond.atom1].push_back(newbond.atom2); _system.connect[newbond.atom2].push_back(newbond.atom1); } break; case 8: break; // No need to keep going. default: continue; }; } // Report total number of bonds. int num_bonds = 0; for (auto c=_system.connect.cbegin(); c!=_system.connect.cend(); ++c) { num_bonds += c->size(); } cout << "Read " << num_bonds/2 << " bonds from the input file.\n"; }
// Reads a LAMMPS dump output file, in atom format. void LAMMPS_Data::read_dump(string path) { fstream fid(path); if (!fid) cout << "Error opening output file " << path << "!\n"; else cout << "Opened dump " << path << ".\n"; SnapshotDump *step=NULL; while (fid) { auto line = trim(read_line(fid)); if (line.empty()) continue; else if (line=="ITEM: TIMESTEP") { _dump.push_back(SnapshotDump()); step = &_dump.back(); step->timestep = str2u32(trim(read_line(fid))); } else if (line=="ITEM: NUMBER OF ATOMS") { if (!step) { cout << "Error: NUMBER OF ATOMS specified before TIMESTEP\n"; exit(1); } unsigned n = str2u32(trim(read_line(fid))); step->scaled_coordinates.assign(n, Coord()); } else if (line.find("ITEM: BOX BOUNDS")==0) { if (!step) { cout << "Error: BOX BOUNDS specified before TIMESTEP\n"; exit(1); } auto xb = split(read_line(fid)); auto yb = split(read_line(fid)); auto zb = split(read_line(fid)); step->dx = fabs(str2dbl(xb.at(1))-str2dbl(xb.at(0))); step->dy = fabs(str2dbl(yb.at(1))-str2dbl(yb.at(0))); step->dz = fabs(str2dbl(zb.at(1))-str2dbl(zb.at(0))); } // The only thing left should be the ATOMS data. else { auto pieces = split(line); if (pieces.size() < 4) continue; if (pieces[0]=="ITEM:" && pieces[1]=="ATOMS") { vector<string> var(pieces.begin()+2, pieces.end()); // Search for coordinate and tag columns. step->xc = step->yc = step->zc = step->zc = -1; step->xs = step->ys = step->zs = 0; for (size_t i=0; i<var.size(); ++i) { if (var[i]=="x") {step->xc=i;} if (var[i]=="xs") {step->xc=i; step->xs=1; } if (var[i]=="y") {step->yc=i;} if (var[i]=="ys") {step->yc=i; step->ys=1; } if (var[i]=="z") {step->zc=i;} if (var[i]=="zs") {step->zc=i; step->zs=1; } if (var[i]=="id") step->tc=i; } if (step->xc<0 || step->yc<0 || step->zc<0) { cout << "Error: coordinate column not found\n"; exit(1); } if (step->tc<0) { cout << "Error: atom tag column not found.\n"; exit(1); } continue; } if (!step) { cout << "Error: data encountered before TIMESTEP\n"; exit(1); } auto maxc=max(step->tc,max(step->xc,max(step->yc,step->zc))); auto minc=min(step->tc,min(step->xc,min(step->yc,step->zc))); if (maxc >= (int)pieces.size()) { cout << "Not enough columns in dump data.\n"; exit(1); } if (minc < 0) { cout << "Missing data column in dump data.\n"; exit(1); } unsigned id = str2u32(pieces[step->tc])-1; if (step->scaled_coordinates.size() <= id) { cout << "Error: invalid atom id found " << id << "\n"; exit(1); } Coord &r = step->scaled_coordinates[id]; r.x = str2dbl(pieces[step->xc]); r.y = str2dbl(pieces[step->yc]); r.z = str2dbl(pieces[step->zc]); // Store coordinates scaled no matter what the input is. if (!step->xs) r.x = to_scaled(r.x, step->dx); if (!step->ys) r.y = to_scaled(r.y, step->dy); if (!step->zs) r.z = to_scaled(r.z, step->dz); } } }
format * mk_compose(ast_manager & m, unsigned num_children, format * const * children) { return fm(m).mk_app(fid(m), OP_COMPOSE, num_children, (expr * const *) children); }
format * mk_compose(ast_manager & m, format * f1, format * f2, format * f3) { return fm(m).mk_app(fid(m), OP_COMPOSE, f1, f2, f3); }
format * mk_compose(ast_manager & m, format * f1, format * f2, format * f3, format * f4) { expr * f[4] = { f1, f2, f3, f4 }; return fm(m).mk_app(fid(m), OP_COMPOSE, 4, f); }
format * mk_nil(ast_manager & m) { return fm(m).mk_app(fid(m), OP_NIL); }
/** * Read power management file and return contained value */ double read_pm_file(const std::string &fname) { double result = 0.; std::ifstream fid(fname.c_str()); fid >> result; return result; }
TPointD XshHandleManager::getHandlePos(const TStageObjectId &id, const std::string &handle, int row) const { static const double unit = 8.0; assert(m_xsh->getScene()); if (handle == "") return TPointD(); else if (handle[0] == 'H' && handle.length() > 1) { // Hook port case if (!id.isColumn()) return TPointD(); int hookIndex = 0; { int h, hLength = handle.length(); for (h = 1; h != hLength; ++h) hookIndex = hookIndex * 10 + (handle[h] - '0'); } TStageObject *obj = m_xsh->getStageObject(id); if (const PlasticSkeletonDeformationP &def = obj->getPlasticSkeletonDeformation()) { int skelId = def->skeletonId(row); PlasticSkeleton skel; def->storeDeformedSkeleton(skelId, row, skel); int v = def->vertexIndex(hookIndex, skelId); return (v >= 0) ? TScale(1.0 / Stage::inch) * skel.vertex(v).P() : TPointD(); } --hookIndex; int col = id.getIndex(); TXshCell cell(m_xsh->getCell(row, col)); TXshLevel *xl = cell.m_level.getPointer(); if (!xl) return TPointD(); TXshSimpleLevel *sl = xl->getSimpleLevel(); if (!sl) return TPointD(); Hook *hook = sl->getHookSet()->getHook(hookIndex); if (!hook) return TPointD(); TFrameId fid(cell.m_frameId); TPointD pos = hook->getAPos(fid) * (1.0 / Stage::inch); TPointD delta; for (int r = row - 1; r >= 0; --r) { cell = m_xsh->getCell(r, col); if (cell.m_level.getPointer() != xl) break; const TFrameId &precFid = cell.m_frameId; delta += computePassHook(fid, precFid, sl, hook); fid = precFid; } pos += delta * (1.0 / Stage::inch); pos = getDpiAffine(sl, cell.m_frameId, true) * pos; return pos; } else if ('A' <= handle[0] && handle[0] <= 'Z') return TPointD(unit * (handle[0] - 'B'), 0); else if ('a' <= handle[0] && handle[0] <= 'z') return TPointD(0.5 * unit * (handle[0] - 'b'), 0); else return TPointD(); }
bool fexist(string filename){ ifstream fid(filename.c_str()); return fid; }
void RichQtfParser::Parse(const char *qtf, int _accesskey) { accesskey = _accesskey; term = qtf; while(*term) { if(Key('[')) { Flush(); fstack.Add(format); for(;;) { int c = *term; if(!c) Error("Unexpected end of text"); term++; if(c == ' ' || c == '\n') break; switch(c) { case 's': { Uuid id; c = *term; if(Key('\"') || Key('\'')) id = target.GetStyleId(GetText(c)); else { int i = ReadNumber(); if(i >= 0 && i < styleid.GetCount()) id = styleid[i]; else id = RichStyle::GetDefaultId(); } const RichStyle& s = target.GetStyle(id); bool p = format.newpage; int lng = format.language; (RichPara::Format&) format = s.format; format.styleid = id; format.language = lng; format.newpage = p; break; } case '/': format.Italic(!format.IsItalic()); break; case '*': format.Bold(!format.IsBold()); break; case '_': format.Underline(!format.IsUnderline()); break; case 'T': format.NonAntiAliased(!format.IsNonAntiAliased()); break; case '-': format.Strikeout(!format.IsStrikeout()); break; case 'c': format.capitals = !format.capitals; break; case 'd': format.dashed = !format.dashed; break; case '`': format.sscript = format.sscript == 1 ? 0 : 1; break; case ',': format.sscript = format.sscript == 2 ? 0 : 2; break; case '^': format.link = GetText('^'); break; case 'I': format.indexentry = FromUtf8(GetText(';')); break; case '+': format.Height(GetNumber()); break; case '@': format.ink = GetColor(); break; case '$': format.paper = GetColor(); break; case 'A': format.Face(Font::ARIAL); break; case 'R': format.Face(Font::ROMAN); break; case 'C': format.Face(Font::COURIER); break; case 'G': format.Face(Font::STDFONT); break; case 'S': #ifdef PLATFORM_WIN32 format.Face(Font::SYMBOL); #endif break; case '.': { int n = GetNumber(); if(n >= Font::GetFaceCount()) Error("Invalid face number"); format.Face(n); break; } case '!': { String fn = GetText('!'); int i = Font::FindFaceNameIndex(fn); if(i < 0) i = Font::ARIAL; format.Face(i); } break; case '{': { String cs = GetText('}'); if(cs.GetLength() == 1) { int c = *cs; if(c == '_') format.charset = CHARSET_UTF8; if(c >= '0' && c <= '8') format.charset = c - '0' + CHARSET_WIN1250; if(c >= 'A' && c <= 'Z') format.charset = c - '0' + CHARSET_ISO8859_1; } else { for(int i = 0; i < CharsetCount(); i++) if(stricmp(CharsetName(i), cs) == 0) { format.charset = i; break; } } break; } case '%': { String h; if(*term == '-') { format.language = 0; term++; } else if(*term == '%') { format.language = LNG_ENGLISH; term++; } else { while(*term && h.GetLength() < 5) h.Cat(*term++); format.language = LNGFromText(h); } break; } case 'g': format.Face(Font::STDFONT); format.Height(GetRichTextScreenStdFontHeight()); break; default: if(c >= '0' && c <= '9') { format.Height(QTFFontHeight[c - '0']); break; } switch(c) { case ':': format.label = GetText(':'); break; case '<': format.align = ALIGN_LEFT; break; case '>': format.align = ALIGN_RIGHT; break; case '=': format.align = ALIGN_CENTER; break; case '#': format.align = ALIGN_JUSTIFY; break; case 'l': format.lm = GetNumber(); break; case 'r': format.rm = GetNumber(); break; case 'i': format.indent = GetNumber(); break; case 'b': format.before = GetNumber(); break; case 'a': format.after = GetNumber(); break; case 'P': format.newpage = !format.newpage; break; case 'k': format.keep = !format.keep; break; case 'K': format.keepnext = !format.keepnext; break; case 'H': format.ruler = GetNumber(); break; case 'h': format.rulerink = GetColor(); break; case 'L': format.rulerstyle = GetNumber(); break; case 'Q': format.orphan = !format.orphan; break; case 'n': format.before_number = GetText(';'); break; case 'm': format.after_number = GetText(';'); break; case 'N': { memset(format.number, 0, sizeof(format.number)); format.reset_number = false; int i = 0; while(i < 8) { int c; if(Key('-')) c = RichPara::NUMBER_NONE; else if(Key('1')) c = RichPara::NUMBER_1; else if(Key('0')) c = RichPara::NUMBER_0; else if(Key('a')) c = RichPara::NUMBER_a; else if(Key('A')) c = RichPara::NUMBER_A; else if(Key('i')) c = RichPara::NUMBER_i; else if(Key('I')) c = RichPara::NUMBER_I; else break; format.number[i++] = c; } if(Key('!')) format.reset_number = true; break; } case 'o': format.bullet = RichPara::BULLET_ROUND; format.indent = 150; break; case 'O': if(Key('_')) format.bullet = RichPara::BULLET_NONE; else { int c = *term++; if(!c) Error("Unexpected end of text"); format.bullet = c == '1' ? RichPara::BULLET_ROUNDWHITE : c == '2' ? RichPara::BULLET_BOX : c == '3' ? RichPara::BULLET_BOXWHITE : c == '9' ? RichPara::BULLET_TEXT : RichPara::BULLET_ROUND; } break; case 'p': switch(*term++) { case 0: Error("Unexpected end of text"); case 'h': format.linespacing = RichPara::LSP15; break; case 'd': format.linespacing = RichPara::LSP20; break; default: format.linespacing = RichPara::LSP10; } break; case 't': if(*term == 'P') { term++; format.newhdrftr = true; format.header_qtf = GetText2('^', '^'); format.footer_qtf = GetText2('^', '^'); } else if(IsDigit(*term)) format.tabsize = ReadNumber(); break; case '~': { if(Key('~')) format.tab.Clear(); else { RichPara::Tab tab; Key('<'); if(Key('>')) tab.align = ALIGN_RIGHT; if(Key('=')) tab.align = ALIGN_CENTER; if(Key('.')) tab.fillchar = 1; if(Key('-')) tab.fillchar = 2; if(Key('_')) tab.fillchar = 3; int rightpos = Key('>') ? RichPara::TAB_RIGHTPOS : 0; tab.pos = rightpos | ReadNumber(); format.tab.Add(tab); } } break; default: continue; } } } SetFormat(); } else if(Key(']')) { Flush(); if(fstack.GetCount()) { format = fstack.Top(); fstack.Drop(); } else Error("Unmatched ']'"); } else if(Key2('{')) { if(oldtab) Error("{{ in ++ table"); if(text.GetLength() || paragraph.GetCount()) EndPart(); table.Add(); int r = IsDigit(*term) ? ReadNumber() : 1; Table().AddColumn(r); while(Key(':')) Table().AddColumn(ReadNumber()); if(breakpage) { RichTable& tab = Table(); RichTable::Format tabformat = tab.GetFormat(); tabformat.newpage = true; tab.SetFormat(tabformat); breakpage = false; } TableFormat(); SetFormat(); } else if(Key2('}')) { if(oldtab) Error("}} in ++ table"); FinishTable(); } else if(Key2('+')) if(oldtab) FinishOldTable(); else { Flush(); if(text.GetLength() || paragraph.GetCount()) EndPart(); Tab& b = table.Add(); b.rown.Add(0); b.hspan = 1; b.Old(); oldtab = true; } else if(Key2('|')) FinishCell(); else if(Key2('-')) { FinishCell(); table.Top().rown.Add(0); } else if(Key2(':')) { if(!oldtab) FinishCell(); TableFormat(oldtab); } else if(Key2('^')) { EndPart(); breakpage = true; } else if(Key2('@')) { ReadObject(); } else if(Key2('@', '$')) { String xu; while(isxdigit(*term)) xu.Cat(*term++); int c = stou(~xu, NULL, 16); if(c >= 32) Cat(c); if(*term == ';') term++; SetFormat(); } else if(Key2('^', 'H')) target.SetHeaderQtf(GetText2('^', '^')); else if(Key2('^', 'F')) target.SetFooterQtf(GetText2('^', '^')); else if(Key2('{', ':')) { Flush(); String field = GetText(':'); String param = GetText(':'); Id fid(field); if(RichPara::fieldtype().Find(fid) >= 0) paragraph.Cat(fid, param, format); Key('}'); } else if(Key('&')) { SetFormat(); EndPart(); } else if(Key2('$')) { Flush(); int i = GetNumber(); Uuid id; RichStyle style; style.format = format; if(Key(',')) stylenext.At(i, 0) = GetNumber(); else stylenext.At(i, 0) = i; if(Key('#')) { String xu; while(isxdigit(*term)) xu.Cat(*term++); if(xu.GetLength() != 32) Error("Invalid UUID !"); id = ScanUuid(xu); } else if(i) id = Uuid::Create(); else id = RichStyle::GetDefaultId(); if(Key(':')) style.name = GetText(']'); if(fstack.GetCount()) { format = fstack.Top(); fstack.Drop(); } target.SetStyle(id, style); styleid.At(i, RichStyle::GetDefaultId()) = id; if(id == RichStyle::GetDefaultId()) { bool p = format.newpage; int lng = format.language; (RichPara::Format&) format = style.format; format.styleid = id; format.language = lng; format.newpage = p; } } else if(*term == '_') { SetFormat(); text.Cat(160); term++; } else if(Key2('-', '|')) { SetFormat(); text.Cat(9); } else if(*term == '\1') { if(istable) EndPart(); SetFormat(); const char *b = ++term; for(; *term && *term != '\1'; term++) { if((byte)*term == '\n') { text.Cat(ToUnicode(b, (int)(term - b), format.charset)); EndPart(); b = term + 1; } if((byte)*term == '\t') { text.Cat(ToUnicode(b, (int)(term - b), format.charset)); text.Cat(9); b = term + 1; } } text.Cat(ToUnicode(b, (int)(term - b), format.charset)); if(*term == '\1') term++; } else { if(!Key('`')) Key('\\'); if((byte)*term >= ' ') { SetFormat(); do { if(istable) EndPart(); if(format.charset == CHARSET_UTF8) { word code = (byte)*term++; if(code <= 0x7F) Cat(code); else if(code <= 0xDF) { if(*term == '\0') break; int c0 = (byte)*term++; if(c0 < 0x80) Error("Invalid UTF-8 sequence"); Cat(((code - 0xC0) << 6) + c0 - 0x80); } else if(code <= 0xEF) { int c0 = (byte)*term++; int c1 = (byte)*term++; if(c0 < 0x80 || c1 < 0x80) Error("Invalid UTF-8 sequence"); Cat(((code - 0xE0) << 12) + ((c0 - 0x80) << 6) + c1 - 0x80); } else Error("Invalid UTF-8 sequence"); } else Cat(ToUnicode((byte)*term++, format.charset)); } while((byte)*term >= 128 || s_nodeqtf[(byte)*term]); } else if(*term) term++; } } // if(paragraph.GetCount() == 0) // TRC 11/02/15: kills formatting of last paragraph in text // SetFormat(); if(oldtab) FinishOldTable(); else while(table.GetCount()) FinishTable(); EndPart(); FlushStyles(); }
format * mk_choice(ast_manager & m, format * f1, format * f2) { return fm(m).mk_app(fid(m), OP_CHOICE, f1, f2); }