void GwfStreamWriter::writePair(SCgObject *obj) { QString type = mTypeAlias2GWFType[obj->typeAlias()].mid(0,3); if(type=="arc") writeStartElement(type); else writeStartElement("pair"); writeObjectAttributes(obj); SCgPair* pair = static_cast<SCgPair*>(obj); SCgObject* b = pair->getBeginObject(); SCgObject* e = pair->getEndObject(); writeAttribute("id_b", QString::number(b->id())); writeAttribute("id_e", QString::number(e->id())); writePosition(b,"b_x","b_y"); writePosition(e,"e_x","e_y"); writeAttribute("dotBBalance", QString::number(pair->getBeginDot())); writeAttribute("dotEBalance", QString::number(pair->getEndDot())); QVector<QPointF> points = pair->scenePoints(); points.pop_back(); points.pop_front(); writePoints(points); writeEndElement(); }
void GwfStreamWriter::writeContour(SCgObject *obj) { writeStartElement("contour"); writeObjectAttributes(obj); SCgContour* contour = static_cast<SCgContour*>(obj); QVector<QPointF> points(contour->scenePoints()); writePoints(points); writeEndElement(); }
void PartitionIO<MeshType>::write (const meshPartsPtr_Type& meshParts) { M_meshPartsOut = meshParts; M_numParts = M_meshPartsOut->size(); M_HDF5IO.openFile (M_fileName, M_comm, false); writeStats(); writePoints(); writeEdges(); writeFaces(); writeElements(); M_HDF5IO.closeFile(); M_meshPartsOut.reset(); }
void GwfStreamWriter::writeBus(SCgObject *obj) { writeStartElement("bus"); writeObjectAttributes(obj); SCgBus* bus = static_cast<SCgBus*>(obj); writeAttribute("owner", QString::number(bus->owner()->id())); QVector<QPointF> points = bus->scenePoints(); writeAttribute("b_x", QString::number(points.first().x())); writeAttribute("b_y", QString::number(points.first().y())); writeAttribute("e_x", QString::number(points.last().x())); writeAttribute("e_y", QString::number(points.last().y())); // do not save begin and end points points.pop_back(); points.pop_front(); writePoints(points); writeEndElement(); }
int main (int argc, char **argv) { Options mergetr = readParameters (argc, argv); char filename_mesh_node[FILENAME_MAX]; char filename_mesh_ele[FILENAME_MAX]; char filename_otoczka[FILENAME_MAX]; char filename_output_node[FILENAME_MAX]; char filename_output_ele[FILENAME_MAX]; int no_of_meshes = argc-mergetr.args_start; strcpy (filename_otoczka, mergetr.input); if ( strstr (filename_otoczka, ".poly") == NULL) strcat (filename_otoczka, ".poly"); strcpy (filename_output_node, mergetr.output); strcat (filename_output_node, ".node"); strcpy (filename_output_ele, mergetr.output); strcat (filename_output_ele, ".ele"); fprintf(stdout, "************************************\n"); fprintf(stdout, "***** M * E * R * G * E * T * R ****\n"); fprintf(stdout, "************************************\n"); fprintf(stdout, "* Otoczka filename: %s\n", filename_otoczka); fprintf(stdout, "* Output filenames: %s & %s\n", filename_output_node, filename_output_ele); fprintf(stdout, "* Triangle options: %s\n", mergetr.tr_opt); fprintf(stdout, "************************************\n"); struct triangulateio *siatka; struct triangulateio otoczka; struct triangulateio out; EdgeList **v; PointList **p; int i; siatka = malloc ( no_of_meshes * sizeof *siatka); v = malloc ( no_of_meshes * sizeof **v ); p = malloc ( no_of_meshes * sizeof **p ); if (siatka == NULL || v == NULL || p == NULL) { fprintf (stderr, "** Error! Not enough memory!"); return -1; } initTriangulation (&otoczka); /* OTOCZKA */ FILE *file_otoczka = fopen( filename_otoczka, "r"); if (file_otoczka == NULL) { fprintf(stderr, "** Error while opening %s\n", filename_otoczka); return -100; } readPoints (file_otoczka, &otoczka); readSegments (file_otoczka, &otoczka); readHoles (file_otoczka, &otoczka); readRegions (file_otoczka, &otoczka); fclose (file_otoczka); /* MESHES */ for (i = 0; i < (argc - mergetr.args_start); i++) { strcpy (filename_mesh_node, argv[mergetr.args_start+i]); strcat (filename_mesh_node, ".node"); strcpy (filename_mesh_ele, argv[mergetr.args_start+i]); strcat (filename_mesh_ele, ".ele"); fprintf(stdout, "************************************\n"); fprintf(stdout, "* Mesh filenames: %s & %s\n", filename_mesh_node, filename_mesh_ele); fprintf(stdout, "************************************\n"); FILE *file_mesh_node = fopen( filename_mesh_node, "r"); FILE *file_mesh_ele = fopen( filename_mesh_ele, "r"); if (file_mesh_node == NULL) { fprintf(stderr, "** Error while opening %s\n", filename_mesh_node); return -101; } if (file_mesh_node == NULL) { fprintf(stderr, "** Error while opening %s\n", filename_mesh_ele); return -102; } initTriangulation (&siatka[i]); readPoints (file_mesh_node, &siatka[i]); readTriangles (file_mesh_ele, &siatka[i]); fclose (file_mesh_node); fclose (file_mesh_ele); v[i] = createEdgeList(siatka[i]); markBndEdges (siatka[i], v[i]); p[i] = makePointList (otoczka, siatka[i], v[i]); updatePoints (&otoczka, siatka[i], v[i], p[i]); updateSegments (&otoczka, siatka[i], v[i], p[i]); updateHoles (&otoczka, siatka[i]); } fprintf(stdout, "************************************\n"); /* TRIANGULAtE */ initTriangulation (&out); strcat (mergetr.tr_opt, "pYYQ"); triangulate (mergetr.tr_opt, &otoczka, &out, (struct triangulateio *) NULL); /* GLUE HOLES */ /* markNotBndEdges (siatka1, v); */ for (i = 0; i < no_of_meshes; i++) { glueNotBndPoints (&out, siatka[i], p[i]); /* DOKLEJANIE DO OUT */ fixPointListNumbers (&out, &siatka[i], p[i]); glueInteriorTriangles (&out, siatka[i], p[i]); removeHole (&out); } FILE *file_output_node = fopen (filename_output_node, "w"); FILE *file_output_ele = fopen (filename_output_ele, "w"); writePoints (file_output_node, out); writeTriangles (file_output_ele, out); fclose (file_output_node); fclose (file_output_ele); fprintf(stdout, "************************************\n"); free (p); free (v); freeTriangulation (&otoczka); freeTriangulation (&out); for (i = 0; i < no_of_meshes; i++) freeTriangulation (&siatka[i]); return 0; }
/* Create GRASS vector output map. Create attribute table. Calculate geometries and write them into the output map. Calculate attributes and write them into the output map's attribute table. */ void writeMap() { int i, j; double xlength, ylength, zlength; double length, flatLength, bailLength; double xoffset, yoffset, zoffset; double xys[12]; int ratio; double zRatio; /* attributes to be written to output map */ int boneID; int skelID; int unitID; int oldID; int cat; char *organization; char buf[MAXSTR]; if ( numPoints < 2 ) { G_fatal_error ("Less than two valid measurement points in input file"); } G_message (_("Constructing geometries for %i valid points:"), numPoints ); /* CREATE OUTPUT VECTOR MAP */ if (Vect_legal_filename(output->answer) < 0) { G_fatal_error(_("Use '%s' option to change vector map name"), output->key); } Map = (struct Map_info *) G_malloc (sizeof ( struct Map_info ) ); if (Vect_open_new(Map, output->answer, WITH_Z) < 0) { G_fatal_error(_("Unable to create vector map <%s>"), output->answer); } Vect_set_map_name(Map, output->answer); Vect_hist_command(Map); if ((organization = getenv("GRASS_ORGANIZATION"))) { Vect_set_organization(Map, organization); } else { Vect_set_organization(Map, "UNKNOWN ORGANIZATION"); } Vect_set_date(Map, G_date()); Vect_set_person(Map, G_whoami()); Vect_set_map_date(Map, ""); Vect_set_scale(Map, 2400); Vect_set_comment(Map, ""); Vect_set_zone(Map, 0); Vect_set_thresh(Map, 0.0); /* START DBMS INTERFACE */ /* prepare strings for use in db_* calls */ db_init_string(&sql); /* start default database driver */ Fi = Vect_default_field_info(Map, 1, NULL, GV_1TABLE); driver = db_start_driver_open_database(Fi->driver,Vect_subst_var(Fi->database, Map)); if (driver == NULL) { Vect_delete(output->answer); G_fatal_error(_("Unable to open database <%s> by driver <%s>"), Vect_subst_var(Fi->database, Map), Fi->driver); } /* create attribute table */ db_begin_transaction ( driver ); sprintf(buf, "create table %s (cat integer, skel_id integer, bone_id integer, unit_id integer, GRASSRGB varchar(11),BONERGB varchar(11));", Fi->table); if ( DEBUG ) { fprintf ( stderr, "Creating attribute table: %s\n", buf ); } db_set_string(&sql, buf); if (db_execute_immediate(driver, &sql) != DB_OK) { Vect_delete(output->answer); G_fatal_error(_("Unable to create attribute table: %s"), db_get_string(&sql)); } if (db_grant_on_table (driver, output->answer, DB_PRIV_SELECT, DB_GROUP | DB_PUBLIC) != DB_OK) { Vect_delete(output->answer); G_fatal_error(_("Unable to grant privileges on table <%s>"), output->answer); } if (db_create_index2(driver, output->answer, "cat") != DB_OK) { G_warning(_("Unable to create index for table <%s>, key <%s>"), output->answer, "cat"); } /* link vector map to attribute table */ if (Vect_map_add_dblink(Map, 1, NULL, Fi->table, "cat", Fi->database, Fi->driver) ) { Vect_delete(output->answer); G_fatal_error(_("Unable to add database link for vector map <%s>"), Vect_get_full_name(Map)); } /* PROCESS POINTS AND WRITE GEOMETRIES */ /* Now process point measurements and write geometries into output vector map. */ /* At this stage, the global points array has an even number of valid points. */ oldID = pointTable[0].SKEL_ID; unitID = 1; cat = 0; for ( i = 0; i < numPoints; i = i + 2 ) { /* This boneID is a generalized ID that does not differentiate between start and end measurement. */ boneID = (int) pointTable[i+1].BONE_ID / 2; skelID = pointTable[i+1].SKEL_ID; /* get coordinates for top and bottom of bone */ ax = pointTable[i].X; ay = pointTable[i].Y; az = pointTable[i].Z; bx = pointTable[i+1].X; by = pointTable[i+1].Y; bz = pointTable[i+1].Z; /* get vector lengths */ xlength = fabs (ax - bx); ylength = fabs (ay - by); zlength = fabs (az - bz); /* get real length */ length = sqrt ( (xlength*xlength) + (ylength*ylength) + (zlength*zlength) ); /* get length in x/y plane */ flatLength = sqrt ( (xlength*xlength) + (ylength*ylength) ); /* determine ratio for triangles, depending on bone type */ ratio = 12; /* default */ for ( j = 0; j < NUM_RATIOS; j ++ ) { if ( boneID == RATIO_ID[j] ) { ratio = RATIO_VAL[j]; } } /* get bail length */ bailLength = (double) ( length / (double) ratio); /* calculate bail offsets from top point (one bail is mirror of the other) */ xoffset = (bailLength * ylength) / flatLength; yoffset = ( (bailLength * xlength) / flatLength ) * (-1); zoffset = 0; xys[0]= ax + xoffset; xys[1]= ay + yoffset; xys[2]= az + zoffset; xys[6]= ax - xoffset; xys[7]= ay - yoffset; xys[8]= az - zoffset; /* get 3rd axis offsets */ zRatio = (zlength/ratio) / flatLength; xoffset = xlength * zRatio; yoffset = ylength * zRatio; zoffset = (flatLength/ratio) * (-1); xys[3]= ax + xoffset; xys[4]= ay + yoffset; xys[5]= az + zoffset; xys[9]= ax - xoffset; xys[10]= ay - yoffset; xys[11]= az - zoffset; /* Increase unit ID by "1", if we have another skeleton ID */ if ( oldID != pointTable[i+1].SKEL_ID ) { unitID ++; oldID = pointTable[i+1].SKEL_ID; /* switch to next colour for next geometry */ RGBNUM ++; if ( RGBNUM == RGBMAX ) { RGBNUM = 0; } } /* write geometries */ if ( MODE == MODE_DARTS ) { writeTriangle ( cat, skelID, boneID, unitID, xys, 0, 6 ); cat ++; writeTriangle ( cat, skelID, boneID, unitID, xys, 3, 9 ); cat ++; } if ( MODE == MODE_LINES ) { writeLine ( cat, skelID, boneID, unitID ); cat ++; } if ( MODE == MODE_PLANES_H ) { writeTriangle ( cat, skelID, boneID, unitID, xys, 0, 6 ); cat ++; } if ( MODE == MODE_PLANES_V ) { writeTriangle ( cat, skelID, boneID, unitID, xys, 3, 9 ); cat ++; } if ( MODE == MODE_POINTS ) { writePoints ( cat, skelID, boneID, unitID ); cat = cat + 2; } if ( MODE == MODE_PYRAMIDS ) { writeTriangle ( cat, skelID, boneID, unitID, xys, 0, 3 ); cat ++; writeTriangle ( cat, skelID, boneID, unitID, xys, 3, 6 ); cat ++; writeTriangle ( cat, skelID, boneID, unitID, xys, 6, 9 ); cat ++; writeTriangle ( cat, skelID, boneID, unitID, xys, 9, 0 ); cat ++; writeSquare ( cat, skelID, boneID, unitID, xys ); cat ++; } /* switch to next colour for bone colouring */ RGBNUM_BONE ++; if ( RGBNUM_BONE == RGBMAX ) { RGBNUM_BONE = 0; } G_percent ( i, numPoints - 2, 1 ); } fprintf ( stdout, "\n" ); /* commit DBMS actions */ db_commit_transaction(driver); db_close_database_shutdown_driver(driver); if (!Vect_build(Map)) { G_warning("Building topology failed"); } Vect_close(Map); db_free_string(&sql); }
int GMSHInterface::writeGMSHInputFile(std::ostream& out) { DBUG("GMSHInterface::writeGMSHInputFile(): get data from GEOObjects."); if (_selected_geometries.empty()) return 1; // *** get and merge data from _geo_objs if (_selected_geometries.size() > 1) { _gmsh_geo_name = "GMSHGeometry"; if (_geo_objs.mergeGeometries(_selected_geometries, _gmsh_geo_name)) return 2; } else { _gmsh_geo_name = _selected_geometries[0]; _keep_preprocessed_geometry = true; } auto* merged_pnts(const_cast<std::vector<GeoLib::Point*>*>( _geo_objs.getPointVec(_gmsh_geo_name))); if (! merged_pnts) { ERR("GMSHInterface::writeGMSHInputFile(): Did not found any points."); return 2; } if (_rotate) { // Rotate points to the x-y-plane. _inverse_rot_mat = GeoLib::rotatePointsToXY(*merged_pnts); // Compute inverse rotation matrix to reverse the rotation later on. _inverse_rot_mat.transposeInPlace(); } else { // project data on the x-y-plane _inverse_rot_mat(0,0) = 1.0; _inverse_rot_mat(1,1) = 1.0; _inverse_rot_mat(2,2) = 1.0; for (auto pnt : *merged_pnts) (*pnt)[2] = 0.0; } std::vector<GeoLib::Polyline*> const* merged_plys( _geo_objs.getPolylineVec(_gmsh_geo_name)); DBUG("GMSHInterface::writeGMSHInputFile(): Obtained data."); if (!merged_plys) { ERR("GMSHInterface::writeGMSHInputFile(): Did not find any polylines."); return 2; } // *** compute and insert all intersection points between polylines GeoLib::PointVec& pnt_vec(*const_cast<GeoLib::PointVec*>( _geo_objs.getPointVecObj(_gmsh_geo_name))); GeoLib::computeAndInsertAllIntersectionPoints(pnt_vec, *(const_cast<std::vector<GeoLib::Polyline*>*>(merged_plys))); // *** compute topological hierarchy of polygons for (auto polyline : *merged_plys) { if (!polyline->isClosed()) { continue; } _polygon_tree_list.push_back(new GMSH::GMSHPolygonTree( new GeoLib::PolygonWithSegmentMarker(*polyline), nullptr, _geo_objs, _gmsh_geo_name, *_mesh_density_strategy)); } DBUG( "GMSHInterface::writeGMSHInputFile(): Computed topological hierarchy - " "detected %d polygons.", _polygon_tree_list.size()); GeoLib::createPolygonTrees<GMSH::GMSHPolygonTree>(_polygon_tree_list); DBUG( "GMSHInterface::writeGMSHInputFile(): Computed topological hierarchy - " "calculated %d polygon trees.", _polygon_tree_list.size()); // *** Mark in each polygon tree the segments shared by two polygons. for (auto* polygon_tree : _polygon_tree_list) { polygon_tree->markSharedSegments(); } // *** insert stations and polylines (except polygons) in the appropriate object of // class GMSHPolygonTree // *** insert stations auto gmsh_stations = std::make_unique<std::vector<GeoLib::Point*>>(); for (auto const& geometry_name : _selected_geometries) { auto const* stations(_geo_objs.getStationVec(geometry_name)); if (stations) { for (auto * station : *stations) { bool found(false); for (auto it(_polygon_tree_list.begin()); it != _polygon_tree_list.end() && !found; ++it) { gmsh_stations->emplace_back(new GeoLib::Station( *static_cast<GeoLib::Station*>(station))); if ((*it)->insertStation(gmsh_stations->back())) { found = true; } } } } } std::string gmsh_stations_name(_gmsh_geo_name+"-Stations"); if (! gmsh_stations->empty()) { _geo_objs.addStationVec(std::move(gmsh_stations), gmsh_stations_name); } // *** insert polylines for (auto polyline : *merged_plys) { if (!polyline->isClosed()) { for (auto * polygon_tree : _polygon_tree_list) { auto polyline_with_segment_marker = new GeoLib::PolylineWithSegmentMarker(*polyline); polygon_tree->insertPolyline(polyline_with_segment_marker); } } } // *** init mesh density strategies for (auto& polygon_tree : _polygon_tree_list) { polygon_tree->initMeshDensityStrategy(); } // *** create GMSH data structures const std::size_t n_merged_pnts(merged_pnts->size()); _gmsh_pnts.resize(n_merged_pnts); for (std::size_t k(0); k<n_merged_pnts; k++) { _gmsh_pnts[k] = nullptr; } for (auto& polygon_tree : _polygon_tree_list) { polygon_tree->createGMSHPoints(_gmsh_pnts); } // *** finally write data :-) writePoints(out); std::size_t pnt_id_offset(_gmsh_pnts.size()); for (auto* polygon_tree : _polygon_tree_list) { polygon_tree->writeLineLoop(_n_lines, _n_plane_sfc, out); polygon_tree->writeSubPolygonsAsLineConstraints(_n_lines, _n_plane_sfc-1, out); polygon_tree->writeLineConstraints(_n_lines, _n_plane_sfc-1, out); polygon_tree->writeStations(pnt_id_offset, _n_plane_sfc-1, out); polygon_tree->writeAdditionalPointData(pnt_id_offset, _n_plane_sfc-1, out); } if (! _keep_preprocessed_geometry) { _geo_objs.removeSurfaceVec(_gmsh_geo_name); _geo_objs.removePolylineVec(_gmsh_geo_name); _geo_objs.removePointVec(_gmsh_geo_name); _geo_objs.removeStationVec(gmsh_stations_name); } return 0; }