geos::geom::MultiPolygon *WKBParser::_readMultiPolygon()
{
int count = _is.readInt();
std::vector<geos::geom::Geometry *> *geoms = new std::vector<geos::geom::Geometry *>(count);
try {
for (int i=0; i<count; i++)
{
geos::geom::Geometry *g = _readGeometry();
if (!dynamic_cast<geos::geom::Polygon *>(g))
{
AMIGO_LOG_E(TAG, "::_readMultiPolygon() Invalid geometry type\n");
_clean(geoms);
return NULL;
}
(*geoms)[i] = g;
}
} catch (...)
{
AMIGO_LOG_E(TAG, "::_readMultiPolygon() Read failed.\n");
_clean(geoms);
return NULL;
}
return _factory.createMultiPolygon(geoms);
}
char* loadFile (const char *fname, int *size)
{
AMIGO_LOG_I(TAG, "::loadFile() %s\n", fname);
int fd=open(fname, O_RDONLY);
if(fd<0)
return NULL;
char *buffer=NULL;
*size=0;
off_t fsize = lseek(fd, 0, SEEK_END);
AMIGO_LOG_I(TAG, "::loadFile() fd=%d, size=%d\n", fd, fsize);
if(fsize>0)
{
buffer = new char[ fsize ];
lseek(fd, 0, SEEK_SET);
int n = read(fd, buffer, fsize);
if(n != fsize)
{
AMIGO_LOG_E(TAG, "::loadFile() %d != %d\n", n, fsize);
delete [] buffer;
return NULL;
}
*size = fsize;
}
else
{
AMIGO_LOG_E(TAG, "::loadFile() FAILED\n");
}
return buffer;
}
bool loadJSON(const std::string &url, std::string &response, bool useCache, bool neededForOffline)
{
if(url.size()==0)
{
AMIGO_LOG_E(TAG, "::loadJSON(): Failed, URL is empty. \n");
return false;
}
AmigoRest client("core/AmigoCore", useCache);
client.enableCacheWrite(useCache || neededForOffline);
RestClient::response resp = client.get(url);
if(!resp.isBad())
{
response = resp.body;
return true;
} else if(!useCache && neededForOffline)
{
client.enableCacheRead(true);
resp = client.get(url);
if(!resp.isBad())
{
response = resp.body;
return true;
}
}
AMIGO_LOG_E(TAG, "::loadJSON(): Failed URL: '%s'\n", url.c_str());
return false;
}
geos::geom::GeometryCollection *WKBParser::_readGeometryCollection()
{
int count = _is.readInt();
std::vector<geos::geom::Geometry *> *geoms = new std::vector<geos::geom::Geometry *>(count);
try {
for (int i=0; i<count; i++)
{
geos::geom::Geometry *g = _readGeometry();
if(g)
{
(*geoms)[i] = g;
} else
{
AMIGO_LOG_E(TAG, "::_readGeometryCollection() Read failed.\n");
_clean(geoms);
return NULL;
}
}
} catch (...)
{
_clean(geoms);
return NULL;
}
return _factory.createGeometryCollection(geoms);
}
geos::geom::Polygon *WKBParser::_readPolygon()
{
int count = _is.readInt();
geos::geom::LinearRing *rind = NULL;
std::vector<geos::geom::Geometry *> *holes=NULL;
if ( count > 0 )
{
try {
if( count > 0 )
{
rind = _readLinearRing();
}
holes = new std::vector<geos::geom::Geometry *>(count-1);
for (int i=0; i<count-1; i++)
{
geos::geom::Geometry *g = (geos::geom::Geometry *)_readLinearRing();
(*holes)[i] = g;
}
} catch (...)
{
if(holes)
{
_clean(holes);
}
if(rind)
{
delete rind;
}
AMIGO_LOG_E(TAG, "::_readPolygon() Read failed.\n");
return NULL;
}
}
return _factory.createPolygon(rind, holes);
}
int getPixelSpan(int mode)
{
int pixelSpan;
switch(mode)
{
case ImageUtils::JPEG:
case ImageUtils::RGB:
pixelSpan = 3;
break;
case ImageUtils::RGBA:
pixelSpan = 4;
break;
case ImageUtils::GRAY_8:
pixelSpan = 1;
break;
case ImageUtils::GRAY_16:
pixelSpan = 2;
break;
default:
AMIGO_LOG_E(TAG, "::getPixelSpan() Error: mode=%d\n", mode);
pixelSpan = 4;
break;
}
return pixelSpan;
}
std::shared_ptr<std::string> fCache::get(const std::string &key)
{
std::stringstream sql;
DatabaseResult result;
sql << "SELECT data FROM " << TABLE_NAME << " WHERE id='" << key << "';";
_db.executeSQL(sql.str().c_str(), result);
if(result.isOK())
{
///////////////////////////////////////////////////////////////////////////
// Update timestamp
sql.str("");
sql << "UPDATE " << TABLE_NAME << " SET timestamp=" << Timestamp::unixTime() << " WHERE id='" << key << "';";
_db.executeSQL(sql.str().c_str());
///////////////////////////////////////////////////////////////////////////
if(result.records.size()==1 && result.records[0].size() == 1)
{
auto readBuffer = std::make_shared<std::string>(std::move(result.records.at(0).at(0)));
if(!readBuffer->empty())
{
return readBuffer;
}
}
} else
{
AMIGO_LOG_E(TAG, "::get() sql failed: '%s'\n", sql.str().c_str());
}
return nullptr;
}
geos::geom::Geometry *WKBParser::_readGeometry()
{
unsigned char byteOrdr = _is.readByte();
if (byteOrdr == WKB_BIG_ENDIAN)
_is.doSwap();
int typeInt = _is.readInt();
int geomType = typeInt & 0xff;
bool zPresent = ((typeInt & 0x80000000) != 0);
if (zPresent) _dimension = 3;
else _dimension = 2; // TODO: handle M values
int srid = 0;
bool sridPresent = ((typeInt & 0x20000000) != 0);
if (sridPresent) srid = _is.readInt();
if ( _ordinates.size() < _dimension )
_ordinates.resize(_dimension);
geos::geom::Geometry *geom=NULL;
switch (geomType) {
case Point_Type :
geom = _readPoint();
break;
case MultiPoint_Type :
geom = _readMultiPoint();
break;
case LineString_Type :
geom = _readLineString();
break;
case MultiLineString_Type :
geom = _readMultiLineString();
break;
case Polygon_Type :
geom = _readPolygon();
break;
case MultiPolygon_Type :
geom = _readMultiPolygon();
break;
case GeometryCollection_Type :
geom = _readGeometryCollection();
break;
default:
AMIGO_LOG_E(TAG, "::_readGeometry() Unknown WKB type (%d)\n", geomType);
return NULL;
}
if(geom) geom->setSRID(srid);
return geom;
}
GLuint BitmapHandler::loadTextureFile(const std::string &fileName, int &width, int &height, int mode, bool useCache)
{
GLuint texId;
width = 0;
height = 0;
texId = _findTexture(fileName, width, height);
if(texId != 0 && useCache)
{
return texId;
}
bool useMipmap;
switch(mode)
{
case TEX_MODE_DEFAULT:
useMipmap=globeConfig::instance()->isUseMipMapTxt();
break;
case TEX_MODE_MIPMAP:
useMipmap=true;
break;
case TEX_MODE_NOMIPMAP:
useMipmap=false;
break;
}
char *buffer = findBmpFile(fileName, width, height, ImageUtils::RGBA, useCache);
if ( buffer == NULL )
{
AMIGO_LOG_E(TAG, "::loadTextureFile() Error loading (%s) image.\n", fileName.c_str());
return 0;
}
glGenTextures ( 1, &texId );
glBindTexture ( GL_TEXTURE_2D, texId );
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D ( GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer );
addTexture(fileName, texId, width, height);
delete [] buffer;
return texId;
}
bool loadJSON(const std::string &url, Document &document, bool useCache, bool neededForOffline)
{
if(url.size()==0)
{
AMIGO_LOG_I(TAG, "::loadJSON(): Failed, URL is empty. \n");
return false;
}
AmigoRest client("core/AmigoCore", useCache);
client.enableCacheWrite(useCache || neededForOffline);
RestClient::response resp = client.get(url);
if(!resp.isBad())
{
if (document.Parse<0>(resp.body.c_str()).HasParseError())
{
AMIGO_LOG_E(TAG, "::loadJSON(): Failed to parse: URL: '%s', JSON: '%s'\n", url.c_str(), resp.body.c_str());
return false;
}
return true;
} else if(!useCache && neededForOffline)
{
client.enableCacheRead(true);
resp = client.get(url);
if(!resp.isBad())
{
if (document.Parse<0>(resp.body.c_str()).HasParseError())
{
AMIGO_LOG_E(TAG, "::loadJSON(): Failed to parse: URL: '%s', JSON: '%s'\n", url.c_str(), resp.body.c_str());
return false;
}
return true;
}
}
AMIGO_LOG_E(TAG, "::loadJSON(): Failed URL: '%s'\n", url.c_str());
return false;
}
bool getJSONBool(const Value &v, const std::string &name, bool def)
{
if(v.HasMember(name.c_str()))
{
if(v[name.c_str()].GetType() == kFalseType || v[name.c_str()].GetType() == kTrueType)
{
return v[name.c_str()].GetBool();
}
else
{
AMIGO_LOG_E(TAG, "::getJSONBool(): Failed to parse: '%s'\n", name.c_str());
}
}
return def;
};
double getJSONDouble(const Value &v, const std::string &name, double def)
{
if(v.HasMember(name.c_str()))
{
if(v[name.c_str()].IsDouble())
{
return v[name.c_str()].GetDouble();
}
else
{
AMIGO_LOG_E(TAG, "::getJSONDouble(): Failed to parse: '%s'\n", name.c_str());
}
}
return def;
}
int getJSONInt(const Value &v, const std::string &name, int def)
{
if(v.HasMember(name.c_str()))
{
if(v[name.c_str()].IsInt())
{
return v[name.c_str()].GetInt();
}
else
{
AMIGO_LOG_E(TAG, "::getJSONInt(): Failed to parse: '%s'\n", name.c_str());
}
}
return def;
};
int getJSONInt(const Document &document, const std::string &name, int def)
{
if(document.HasMember(name.c_str()))
{
if(document[name.c_str()].IsInt())
{
return document[name.c_str()].GetInt();
}
else
{
AMIGO_LOG_E(TAG, "::getJSONInt(): Failed to parse: '%s'\n", name.c_str());
}
}
return def;
};
std::string getJSONString(const Value &v, const std::string &name, const std::string &def)
{
if(v.HasMember(name.c_str())) {
if(v[name.c_str()].GetType() == kStringType)
{
const char * str = v[name.c_str()].GetString();
if(str!=NULL)
{
if (strnlen(str, 2) > 0) {
std::string ret = std::string(str);
return ret;
}
} else
{
AMIGO_LOG_E(TAG, "::getJSONString(): Failed to parse: '%s'\n", name.c_str());
}
}
}
return def;
};
char* load_JPEG_FromURL (const char *url, int *width, int *height, bool useCache )
{
// AmigoCloud::CurlHandler ch;
// if( !ch.doRequest(url) )
// return 0;
AmigoRest restClient(imageUtilsUserAgent.c_str(), useCache);
//restClient.setIgnoreSSLCertificate(true); // because of certficate problems.
RestClient::response response = restClient.get(url);
if (response.isBad())
return 0;
/* This struct contains the JPEG decompression parameters and pointers to
* working space (which is allocated as needed by the JPEG library).
*/
struct jpeg_decompress_struct cinfo;
/* We use our private extension JPEG error handler.
* Note that this struct must live as long as the main JPEG parameter
* struct, to avoid dangling-pointer problems.
*/
struct my_error_mgr jerr;
/* More stuff */
// FILE * infile; /* source file */
JSAMPARRAY buffer; /* Output row buffer */
int row_stride; /* physical row width in output buffer */
/* In this example we want to open the input file before doing anything else,
* so that the setjmp() error recovery below can assume the file is open.
* VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
* requires it in order to read binary files.
*/
// if ((infile = fopen(filename, "rb")) == NULL) {
// fprintf(stderr, "can't open %s\n", filename);
// return 0;
// }
/* Step 1: allocate and initialize JPEG decompression object */
/* We set up the normal JPEG error routines, then override error_exit. */
cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = my_error_exit;
/* Establish the setjmp return context for my_error_exit to use. */
if (setjmp(jerr.setjmp_buffer)) {
/* If we get here, the JPEG code has signaled an error.
* We need to clean up the JPEG object, close the input file, and return.
*/
jpeg_destroy_decompress(&cinfo);
// fclose(infile);
return NULL;
}
/* Now we can initialize the JPEG decompression object. */
jpeg_create_decompress(&cinfo);
/* Step 2: specify data source (eg, a file) */
FILE * infile = fmemopen((void*)response.body.c_str(), response.body.size(), "rb");
if (infile == NULL)
{
AMIGO_LOG_E(TAG, "Calling fmemopen() has failed.\n");
// exit(1);
return NULL;
}
jpeg_stdio_src(&cinfo, infile);
/* Step 3: read file parameters with jpeg_read_header() */
(void) jpeg_read_header(&cinfo, TRUE);
/* We can ignore the return value from jpeg_read_header since
* (a) suspension is not possible with the stdio data source, and
* (b) we passed TRUE to reject a tables-only JPEG file as an error.
* See libjpeg.doc for more info.
*/
/* Step 4: set parameters for decompression */
/* In this example, we don't need to change any of the defaults set by
* jpeg_read_header(), so we do nothing here.
*/
/* Step 5: Start decompressor */
(void) jpeg_start_decompress(&cinfo);
/* We can ignore the return value since suspension is not possible
* with the stdio data source.
*/
/* We may need to do some setup of our own at this point before reading
* the data. After jpeg_start_decompress() we have the correct scaled
* output image dimensions available, as well as the output colormap
* if we asked for color quantization.
* In this example, we need to make an output work buffer of the right size.
*/
*width = cinfo.output_width;
*height = cinfo.output_height;
int numcomp = 4;//cinfo.num_components;
row_stride = cinfo.output_width * numcomp;//cinfo.output_components;
char *buff = new char[ *width * *height * numcomp ];
// printf("load_JPEG_FromURL() %dx%d, %d, buff=%p\n", *width, *height, numcomp, buff);
/* JSAMPLEs per row in output buffer */
// char *buffS = new char[ row_stride ];
/* Step 6: while (scan lines remain to be read) */
/* jpeg_read_scanlines(...); */
/* Here we use the library's state variable cinfo.output_scanline as the
* loop counter, so that we don't have to keep track ourselves.
*/
/* Make a one-row-high sample array that will go away when done with image */
buffer = (*cinfo.mem->alloc_sarray)
((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
while (cinfo.output_scanline < cinfo.output_height) {
/* jpeg_read_scanlines expects an array of pointers to scanlines.
* Here the array is only one element long, but you could ask for
* more than one scanline at a time if that's more convenient.
*/
(void) jpeg_read_scanlines(&cinfo, buffer, 1);
/* Assume put_scanline_someplace wants a pointer and sample count. */
int index = (cinfo.output_scanline-1) * row_stride;
// Convert RGB to RGBA
int cb=0;
char *bb = (char*)buffer[0];
for(int i=0; i<row_stride; i+=4 )
{
buff[index + i] = bb[cb]; cb++;
buff[index + i+1] = bb[cb]; cb++;
buff[index + i+2] = bb[cb]; cb++;
buff[index + i+3] = 255;
}
// memcpy((void*)&buff[(cinfo.output_scanline-1) * row_stride], buffS, row_stride);
}
// delete [] buffS;
/* Step 7: Finish decompression */
(void) jpeg_finish_decompress(&cinfo);
/* We can ignore the return value since suspension is not possible
* with the stdio data source.
*/
/* Step 8: Release JPEG decompression object */
/* This is an important step since it will release a good deal of memory. */
jpeg_destroy_decompress(&cinfo);
/* After finish_decompress, we can close the input file.
* Here we postpone it until after no more JPEG errors are possible,
* so as to simplify the setjmp error logic above. (Actually, I don't
* think that jpeg_destroy can do an error exit, but why assume anything...)
*/
fclose(infile);
/* At this point you may want to check to see whether any corrupt-data
* warnings occurred (test whether jerr.pub.num_warnings is nonzero).
*/
// printf("load_JPEG_FromURL() done.\n");
/* And we're done! */
return buff;
}
iiMath::vec4f StyleData::_parseColor(const std::string &hex, bool &valid)
{
iiMath::vec4f v;
if(hex.size()<1)
{
AMIGO_LOG_I(TAG, "::_parse_color() Error: color is not valid\n");
valid = false;
return v;
}
int value = 0;
int a = 0;
int b = hex.length() - 1;
int index=0;
for (; b > 0; a++, b--)
{
if (hex[b] >= '0' && hex[b] <= '9')
{
value += (hex[b] - '0') * (1 << (a * 4));
}
else
{
switch (hex[b])
{
case 'A':
case 'a':
value += 10 * (1 << (a * 4));
break;
case 'B':
case 'b':
value += 11 * (1 << (a * 4));
break;
case 'C':
case 'c':
value += 12 * (1 << (a * 4));
break;
case 'D':
case 'd':
value += 13 * (1 << (a * 4));
break;
case 'E':
case 'e':
value += 14 * (1 << (a * 4));
break;
case 'F':
case 'f':
value += 15 * (1 << (a * 4));
break;
default:
AMIGO_LOG_E(TAG, "::_parseColor() '%s' Error, invalid charactare '%d' in hex number\n", hex.c_str(), hex[a]);
return v;
}
}
}
valid = true;
int vv= value;
v.v[0] = (0x000000ff&(vv>>16)) / 255.0;
vv= value;
v.v[1] = (0x000000ff&(vv>>8)) / 255.0;
vv= value;
v.v[2] = (0x000000ff&(vv)) / 255.0;
v.v[3] = 1;
return v;
}
void VectorLayerEditor::_init()
{
if(_inited)
return;
// Load geometry
AmigoApplicationData &appData = AmigoApplication::instance().getData();
if(auto project = appData.getUser().projects.findProject(_editorParams.projectId))
{
std::vector<std::string> wkbOut;
std::shared_ptr<APIv1::Dataset> ds = std::dynamic_pointer_cast<APIv1::Dataset>(project->datasets.findDataset(_editorParams.datasetId));
if(ds)
{
if(_editorParams.savedWkb.empty())
{
project->db.geoQueryWKB(ds->table_name, _editorParams.jsonRecord, wkbOut, ds->online_only);
AMIGO_LOG_I(TAG, "::_init() wkbOut.size()=%d\n", wkbOut.size());
}
else
{
AMIGO_LOG_I(TAG, "::_init() restore '%s'\n", _editorParams.savedWkb.c_str());
_geometry = GeometryHandler::parseWKBHex(_editorParams.savedWkb);
}
if(_geometry == NULL)
{
if(wkbOut.size()==1 && wkbOut[0].size()>0)
{
AMIGO_LOG_I(TAG, "::_init() '%s'\n", wkbOut[0].c_str());
_geometry = GeometryHandler::parseWKBHex(wkbOut[0]);
} else {
// There is no geometry
_createEmptyGeometry();
}
}
if(_geometry!=NULL)
{
GeometryTypeId gtype = _geometry->getGeometryTypeId();
int type;
switch (gtype) {
case GEOS_POINT:
type = ShapeEditor::T_POINT;
break;
case GEOS_LINESTRING:
type = ShapeEditor::T_LINE;
break;
case GEOS_LINEARRING:
type = ShapeEditor::T_LINE;
break;
case GEOS_POLYGON:
type = ShapeEditor::T_POLYGON;
break;
case GEOS_MULTIPOINT:
type = ShapeEditor::T_POINTS;
break;
case GEOS_MULTILINESTRING:
type = ShapeEditor::T_LINES;
break;
case GEOS_MULTIPOLYGON:
type = ShapeEditor::T_POLYGONS;
break;
case GEOS_GEOMETRYCOLLECTION:
type = ShapeEditor::T_POINTS;
break;
default:
type = ShapeEditor::T_POINTS;
break;
};
AMIGO_LOG_I(TAG, "::_init() type=%d, gtype=%d\n", type, gtype);
_coords.clear();
for(size_t g = 0; g < _geometry->getNumGeometries(); g++)
{
PointList pList;
CoordinateSequence *cs = _geometry->getGeometryN(g)->getCoordinates();
// Remove closing point in polygons
unsigned size = cs->getSize() - ((type == ShapeEditor::T_POLYGONS || type == ShapeEditor::T_POLYGON)? 1 : 0);
for(unsigned i=0; i < size; i++ )
{
Coordinate c;
cs->getAt(i, c);
double alt = Globe::instance()->getGlobeSceneHandler()->getElevationAt( c.y, c.x);
pList.push_back( iiMath::vec3(c.y, c.x, alt) );
}
_coords.push_back(pList);
delete cs;
}
_shapeEditor.load(type, _coords);
}
}
else
{
AMIGO_LOG_E(TAG, "::_init() dataset not found: %lu\n", _editorParams.datasetId);
}
} else
{
AMIGO_LOG_E(TAG, "::_init() project not found: %lu\n", _editorParams.projectId);
}
_shapeEditor.setState(GeometryEditorListener::NO_SELECTION);
_labelStateSet = std::make_shared<LabelVectorStateSet>(false);
_labelDrawSet = std::make_shared<DrawSetT>();
_labelDrawSet->setStateSet(_labelStateSet);
_inited=true;
}
