Beispiel #1
0
 std::unique_ptr<OGRLineString> create_linestring(const osmium::Way& way) {
     std::unique_ptr<OGRLineString> geom = m_factory.create_linestring(way);
     OGREnvelope env;
     geom->getEnvelope(&env);
     m_envelope.Merge(env);
     return geom;
 }
Beispiel #2
0
 std::unique_ptr<OGRMultiPolygon> create_multipolygon(const osmium::Area& area) {
     std::unique_ptr<OGRMultiPolygon> geom = m_factory.create_multipolygon(area);
     OGREnvelope env;
     geom->getEnvelope(&env);
     m_envelope.Merge(env);
     return geom;
 }
Beispiel #3
0
 std::unique_ptr<OGRPoint> create_point(const osmium::Node& node) {
     std::unique_ptr<OGRPoint> geom = m_factory.create_point(node);
     OGREnvelope env;
     geom->getEnvelope(&env);
     m_envelope.Merge(env);
     return geom;
 }
Beispiel #4
0
void CookieCutter::cut(OsmMapPtr cutterShapeMap, OsmMapPtr doughMap)
{
  OGREnvelope env = cutterShapeMap->calculateBounds();
  env.Merge(doughMap->calculateBounds());

  // reproject the dough and cutter into the same planar projection.
  MapReprojector::reprojectToPlanar(doughMap, env);
  MapReprojector::reprojectToPlanar(cutterShapeMap, env);

  // create a complex geometry representing the alpha shape
  UnionPolygonsVisitor v;
  cutterShapeMap->visitRo(v);
  shared_ptr<Geometry> cutterShape = v.getUnion();

  if (_outputBuffer != 0.0)
  {
    cutterShape.reset(cutterShape->buffer(_outputBuffer));
  }

  if (cutterShape->getArea() == 0.0)
  {
    LOG_WARN("Cutter area is zero. Try increasing the buffer size or check the input.");
  }

  // free up a little RAM
  cutterShapeMap.reset();
  // remove the cookie cutter portion from the "dough"
  // if crop is true, then the cookie cutter portion is kept and the "dough" is dropped.
  MapCropper::crop(doughMap, cutterShape, !_crop);
  // clean up any ugly bits left over
  SuperfluousWayRemover::removeWays(doughMap);
  SuperfluousNodeRemover::removeNodes(doughMap);
}
Beispiel #5
0
OGREnvelope wxGISMap::GetFullExtent(void)
{
	OGREnvelope res;
	for(size_t i = 0; i < m_Layers.size(); i++)
		//check if the spatial ref is same!!!
		res.Merge(*m_Layers[i]->GetEnvelope());
	return res;
}
void wxAxIdentifyView::OnMenu(wxCommandEvent& event)
{
	wxTreeItemId TreeItemId = m_pTreeCtrl->GetSelection();
    wxIdentifyTreeItemData* pData = (wxIdentifyTreeItemData*)m_pTreeCtrl->GetItemData(TreeItemId);
    if(pData == NULL)
		return;

	switch(event.GetId())
	{
	case ID_WGMENU_FLASH:
	{
        if (pData->m_Geometry.IsOk())
        {
            m_pMapView->AddFlashGeometry(pData->m_Geometry, GetDrawSymbol(pData->m_Geometry.GetType()));
        }
		else
		{
            wxTreeItemIdValue cookie;
			for ( wxTreeItemId item = m_pTreeCtrl->GetFirstChild(TreeItemId, cookie); item.IsOk(); item = m_pTreeCtrl->GetNextChild(TreeItemId, cookie) )
			{
				pData = (wxIdentifyTreeItemData*)m_pTreeCtrl->GetItemData(item);
                if (pData)
                {
                    m_pMapView->AddFlashGeometry(pData->m_Geometry, GetDrawSymbol(pData->m_Geometry.GetType()));
                }
			}
		}
        m_pMapView->StartFlashing();
	}
	break;
	case ID_WGMENU_PAN:
	{
        wxGISGeometryArray Arr;
		if(pData->m_Geometry.IsOk())
        {
            m_pMapView->AddFlashGeometry(pData->m_Geometry, GetDrawSymbol(pData->m_Geometry.GetType()));
            Arr.Add(pData->m_Geometry);
        }
		else
		{
            wxTreeItemIdValue cookie;
			for ( wxTreeItemId item = m_pTreeCtrl->GetFirstChild(TreeItemId, cookie); item.IsOk(); item = m_pTreeCtrl->GetNextChild(TreeItemId, cookie) )
			{
				pData = (wxIdentifyTreeItemData*)m_pTreeCtrl->GetItemData(item);
				if(pData)
                {
                    m_pMapView->AddFlashGeometry(pData->m_Geometry, GetDrawSymbol(pData->m_Geometry.GetType()));
                    Arr.Add(pData->m_Geometry);
                }
			}
		}

        if(Arr.IsEmpty())
            return;

		OGREnvelope Env;
		for(size_t i = 0; i < Arr.GetCount(); ++i)
		{
            OGREnvelope TempEnv = Arr[i].GetEnvelope();
			Env.Merge(TempEnv);
		}
		OGREnvelope CurrentEnv = m_pMapView->GetCurrentExtent();
		MoveEnvelope(CurrentEnv, Env);
		m_pMapView->Do(CurrentEnv);
        m_pMapView->StartFlashing();
	}
	break;
	case ID_WGMENU_ZOOM:
	{
        wxGISGeometryArray Arr;

		if(pData->m_Geometry.IsOk())
        {
            m_pMapView->AddFlashGeometry(pData->m_Geometry, GetDrawSymbol(pData->m_Geometry.GetType()));
            Arr.Add(pData->m_Geometry);
        }
		else
		{
			wxTreeItemIdValue cookie;
			for ( wxTreeItemId item = m_pTreeCtrl->GetFirstChild(TreeItemId, cookie); item.IsOk(); item = m_pTreeCtrl->GetNextChild(TreeItemId, cookie) )
			{
				pData = (wxIdentifyTreeItemData*)m_pTreeCtrl->GetItemData(item);
				if(pData)
                {
                    m_pMapView->AddFlashGeometry(pData->m_Geometry, GetDrawSymbol(pData->m_Geometry.GetType()));
                    Arr.Add(pData->m_Geometry);
                }
			}
		}

        if(Arr.IsEmpty())
            return;

		OGREnvelope Env;
		for(size_t i = 0; i < Arr.GetCount(); ++i)
		{
			OGREnvelope TempEnv = Arr[i].GetEnvelope();
			Env.Merge(TempEnv);
		}
		m_pMapView->Do(Env);
        m_pMapView->StartFlashing();
	}
	break;
	default:
	break;
	}
}
OGRErr PDFWritableVectorDataset::SyncToDisk()
{
    if (nLayers == 0 || !bModified)
        return OGRERR_NONE;

    bModified = FALSE;

    OGREnvelope sGlobalExtent;
    int bHasExtent = FALSE;
    for(int i=0;i<nLayers;i++)
    {
        OGREnvelope sExtent;
        if (papoLayers[i]->GetExtent(&sExtent) == OGRERR_NONE)
        {
            bHasExtent = TRUE;
            sGlobalExtent.Merge(sExtent);
        }
    }
    if (!bHasExtent ||
        sGlobalExtent.MinX == sGlobalExtent.MaxX ||
        sGlobalExtent.MinY == sGlobalExtent.MaxY)
    {
        CPLError(CE_Failure, CPLE_AppDefined,
                 "Cannot compute spatial extent of features");
        return OGRERR_FAILURE;
    }

    PDFCompressMethod eStreamCompressMethod = COMPRESS_DEFLATE;
    const char* pszStreamCompressMethod = CSLFetchNameValue(papszOptions, "STREAM_COMPRESS");
    if (pszStreamCompressMethod)
    {
        if( EQUAL(pszStreamCompressMethod, "NONE") )
            eStreamCompressMethod = COMPRESS_NONE;
        else if( EQUAL(pszStreamCompressMethod, "DEFLATE") )
            eStreamCompressMethod = COMPRESS_DEFLATE;
        else
        {
            CPLError( CE_Warning, CPLE_NotSupported,
                    "Unsupported value for STREAM_COMPRESS.");
        }
    }

    const char* pszGEO_ENCODING =
        CSLFetchNameValueDef(papszOptions, "GEO_ENCODING", "ISO32000");

    double dfDPI = CPLAtof(CSLFetchNameValueDef(papszOptions, "DPI", "72"));
    if (dfDPI < 72.0)
        dfDPI = 72.0;

    const char* pszNEATLINE = CSLFetchNameValue(papszOptions, "NEATLINE");

    int nMargin = atoi(CSLFetchNameValueDef(papszOptions, "MARGIN", "0"));

    PDFMargins sMargins;
    sMargins.nLeft = nMargin;
    sMargins.nRight = nMargin;
    sMargins.nTop = nMargin;
    sMargins.nBottom = nMargin;

    const char* pszLeftMargin = CSLFetchNameValue(papszOptions, "LEFT_MARGIN");
    if (pszLeftMargin) sMargins.nLeft = atoi(pszLeftMargin);

    const char* pszRightMargin = CSLFetchNameValue(papszOptions, "RIGHT_MARGIN");
    if (pszRightMargin) sMargins.nRight = atoi(pszRightMargin);

    const char* pszTopMargin = CSLFetchNameValue(papszOptions, "TOP_MARGIN");
    if (pszTopMargin) sMargins.nTop = atoi(pszTopMargin);

    const char* pszBottomMargin = CSLFetchNameValue(papszOptions, "BOTTOM_MARGIN");
    if (pszBottomMargin) sMargins.nBottom = atoi(pszBottomMargin);

    const char* pszExtraImages = CSLFetchNameValue(papszOptions, "EXTRA_IMAGES");
    const char* pszExtraStream = CSLFetchNameValue(papszOptions, "EXTRA_STREAM");
    const char* pszExtraLayerName = CSLFetchNameValue(papszOptions, "EXTRA_LAYER_NAME");

    const char* pszOGRDisplayField = CSLFetchNameValue(papszOptions, "OGR_DISPLAY_FIELD");
    const char* pszOGRDisplayLayerNames = CSLFetchNameValue(papszOptions, "OGR_DISPLAY_LAYER_NAMES");
    int bWriteOGRAttributes = CSLFetchBoolean(papszOptions, "OGR_WRITE_ATTRIBUTES", TRUE);
    const char* pszOGRLinkField = CSLFetchNameValue(papszOptions, "OGR_LINK_FIELD");

    const char* pszOffLayers = CSLFetchNameValue(papszOptions, "OFF_LAYERS");
    const char* pszExclusiveLayers = CSLFetchNameValue(papszOptions, "EXCLUSIVE_LAYERS");

    const char* pszJavascript = CSLFetchNameValue(papszOptions, "JAVASCRIPT");
    const char* pszJavascriptFile = CSLFetchNameValue(papszOptions, "JAVASCRIPT_FILE");

/* -------------------------------------------------------------------- */
/*      Create file.                                                    */
/* -------------------------------------------------------------------- */
    VSILFILE* fp = VSIFOpenL(GetDescription(), "wb");
    if( fp == NULL )
    {
        CPLError( CE_Failure, CPLE_OpenFailed,
                  "Unable to create PDF file %s.\n",
                  GetDescription() );
        return OGRERR_FAILURE;
    }

    GDALPDFWriter oWriter(fp);

    double dfRatio = (sGlobalExtent.MaxY - sGlobalExtent.MinY) / (sGlobalExtent.MaxX - sGlobalExtent.MinX);

    int nWidth, nHeight;

    if (dfRatio < 1)
    {
        nWidth = 1024;
        nHeight = nWidth * dfRatio;
    }
    else
    {
        nHeight = 1024;
        nWidth = nHeight / dfRatio;
    }

    GDALDataset* poSrcDS = MEMDataset::Create( "MEM:::", nWidth, nHeight, 0, GDT_Byte, NULL );

    double adfGeoTransform[6];
    adfGeoTransform[0] = sGlobalExtent.MinX;
    adfGeoTransform[1] = (sGlobalExtent.MaxX - sGlobalExtent.MinX) / nWidth;
    adfGeoTransform[2] = 0;
    adfGeoTransform[3] = sGlobalExtent.MaxY;
    adfGeoTransform[4] = 0;
    adfGeoTransform[5] = - (sGlobalExtent.MaxY - sGlobalExtent.MinY) / nHeight;

    poSrcDS->SetGeoTransform(adfGeoTransform);

    OGRSpatialReference* poSRS = papoLayers[0]->GetSpatialRef();
    if (poSRS)
    {
        char* pszWKT = NULL;
        poSRS->exportToWkt(&pszWKT);
        poSrcDS->SetProjection(pszWKT);
        CPLFree(pszWKT);
    }

    oWriter.SetInfo(poSrcDS, papszOptions);

    oWriter.StartPage(poSrcDS,
                      dfDPI,
                      pszGEO_ENCODING,
                      pszNEATLINE,
                      &sMargins,
                      eStreamCompressMethod,
                      bWriteOGRAttributes);

    int iObj = 0;
    
    char** papszLayerNames = CSLTokenizeString2(pszOGRDisplayLayerNames,",",0);

    for(int i=0;i<nLayers;i++)
    {
        CPLString osLayerName;
        if (CSLCount(papszLayerNames) < nLayers)
            osLayerName = papoLayers[i]->GetName();
        else
            osLayerName = papszLayerNames[i];

        oWriter.WriteOGRLayer((OGRDataSourceH)this,
                              i,
                              pszOGRDisplayField,
                              pszOGRLinkField,
                              osLayerName,
                              bWriteOGRAttributes,
                              iObj);
    }

    CSLDestroy(papszLayerNames);

    oWriter.EndPage(pszExtraImages,
                    pszExtraStream,
                    pszExtraLayerName,
                    pszOffLayers,
                    pszExclusiveLayers);

    if (pszJavascript)
        oWriter.WriteJavascript(pszJavascript);
    else if (pszJavascriptFile)
        oWriter.WriteJavascriptFile(pszJavascriptFile);

    oWriter.Close();

    delete poSrcDS;

    return OGRERR_NONE;
}
Beispiel #8
0
void wxGISMapView::AddLayer(wxGISLayer* pLayer)
{
	IDisplayTransformation* pDisplayTransformation = pGISScreenDisplay->GetDisplayTransformation();
	if(pDisplayTransformation->GetSpatialReference() == NULL)
	{
		OGRSpatialReference* pSpaRef = pLayer->GetSpatialReference();
		if(pSpaRef)
			pDisplayTransformation->SetSpatialReference(pSpaRef);
		else
		{
			OGREnvelope* pEnv = pLayer->GetEnvelope();
			if(pEnv)
			{
				if(pEnv->MaxX <= 180 && pEnv->MaxY <= 90 && pEnv->MinX >= -180 && pEnv->MinY >= -90)
				{
					OGRSpatialReference* pSpaRef = new OGRSpatialReference();
					pSpaRef->SetWellKnownGeogCS("WGS84");
					pDisplayTransformation->SetSpatialReference(pSpaRef);
				}
			}
		}
	}
	
	OGREnvelope* pEnv = pLayer->GetEnvelope();
	if(pEnv == NULL)
		return;
	OGRSpatialReference* pSpaRef = pLayer->GetSpatialReference();

	if(pSpaRef && pDisplayTransformation->GetSpatialReference())
	{
		if(!pDisplayTransformation->GetSpatialReference()->IsSame(pSpaRef))
		{
			OGRCoordinateTransformation *poCT = OGRCreateCoordinateTransformation( pSpaRef, pDisplayTransformation->GetSpatialReference() );
			poCT->Transform(1, &pEnv->MaxX, &pEnv->MaxY);
			poCT->Transform(1, &pEnv->MinX, &pEnv->MinY);
		}
	}

	if(!pDisplayTransformation->IsBoundsSet())
		pDisplayTransformation->SetBounds(*pEnv);
	else
	{
		OGREnvelope Bounds = pDisplayTransformation->GetBounds();
		Bounds.Merge(*pEnv);
		pDisplayTransformation->SetBounds(Bounds);
	}

	//caching
	if(pLayer->GetCached())
	{
		pLayer->SetCacheID(pGISScreenDisplay->AddCache());
	}
	else
	{
		if(m_Layers.size() > 0 && m_Layers[m_Layers.size() - 1]->GetCached())
			pLayer->SetCacheID(pGISScreenDisplay->AddCache());
		else
			pLayer->SetCacheID(pGISScreenDisplay->GetLastCacheID());
	}
	wxGISMap::AddLayer(pLayer);
}