void NSRPopplerDocument::renderPage(int page)
{
	double dpix, dpiy;

	if (_doc == NULL || page > getNumberOfPages() || page < 1)
		return;

	_page = _catalog->getPage(page);

	if (isTextOnly()) {
		PDFRectangle	*rect;
		GooString	*text;
		TextOutputDev	*dev;

		dev = new TextOutputDev (0, gFalse, gFalse, gFalse);

		_doc->displayPageSlice(dev, _page->getNum(), 72, 72, 0, gFalse, gTrue, gFalse, -1, -1, -1, -1);

		rect = _page->getCropBox();
		text = dev->getText(rect->x1, rect->y1, rect->x2, rect->y2);
		_text = processText(QString::fromUtf8(text->getCString()));

		delete text;
		delete dev;
		_readyForLoad = true;

		return;
	}

	if (isZoomToWidth()) {
		double wZoom = ((double) getScreenWidth() / (double) _page->getCropWidth() * 100.0);
		setZoomSilent((int) wZoom);
	}

	if (getZoom() > getMaxZoom())
		setZoomSilent (getMaxZoom());
	else if (getZoom() < getMinZoom())
		setZoomSilent (getMinZoom());

	if (_readyForLoad)
		_dev->startPage(0, NULL);

	dpix = _dpix * getZoom() / 100.0;
	dpiy = _dpiy * getZoom() / 100.0;

	_page->display(_dev, dpix, dpiy, getRotation(), gFalse, gFalse, gTrue, _catalog);

	_readyForLoad = true;
}
bool ZDvidDataSliceHelper::actualContainedIn(
    const ZStackViewParam &viewParam, int zoom, int centerCutX, int centerCutY,
    bool centerCut) const
{
  bool contained = false;

  if (m_currentViewParam.getViewPort().isEmpty() &&
      !viewParam.getViewPort().isEmpty()) {
    if (m_currentViewParam.getSliceAxis() == neutube::EAxis::ARB) {
      //Must be on the same plane to be contained
      if (m_currentViewParam.getSliceViewParam().hasSamePlaneCenter(
            viewParam.getSliceViewParam())) {
        contained = true;
      }
    } else {
      if (viewParam.getZ() == m_currentViewParam.getZ()) {
        contained = true;
      }
    }
  } else if (viewParam.contains(m_currentViewParam)) {
    contained = ZDvidDataSliceHelper::IsResIncreasing(
          m_actualZoom, m_actualCenterCutWidth, m_actualCenterCutHeight,
          m_actualUsingCenterCut,
          zoom, centerCutX, centerCutY, centerCut,
          getWidth(), getHeight(), getMaxZoom());
  }

  return contained;
}
bool ZDvidDataSliceHelper::hasNewView(const ZStackViewParam &viewParam) const
{
  int maxZoomLevel = getMaxZoom();

  return !m_currentViewParam.contains(viewParam) ||
      (viewParam.getZoomLevel(maxZoomLevel) <
      m_currentViewParam.getZoomLevel(maxZoomLevel));
}
int ZDvidDataSliceHelper::getLowresZoom() const
{
  int zoom = getZoom() + 1;
  if (zoom > getMaxZoom()) {
    zoom -= 1;
  }

  return zoom;
}
int NSRPopplerDocument::getMinZoom()
{
	if (_page == NULL)
		return 0;

	if (QSize (_page->getCropWidth(), _page->getCropHeight()) == _cachedPageSize)
		return _cachedMinZoom;

	/* Each pixel needs 4 bytes (RGBA) of memory */
	double pageSize = _page->getCropWidth() * _page->getCropHeight() * 4;

	if (pageSize > NSR_DOCUMENT_MAX_HEAP)
		_cachedMinZoom = getMaxZoom();
	else
		_cachedMinZoom = (getMaxZoom() / 10) > 25 ? 25 : getMaxZoom() / 10;

	_cachedPageSize = QSize (_page->getCropWidth(), _page->getCropHeight());

	return _cachedMinZoom;
}
bool ZDvidDataSliceHelper::needHighResUpdate() const
{
  if (getViewDataSize() == 0) {
    return true;
  }

  return IsResIncreasing(
        m_actualZoom, m_actualCenterCutWidth, m_actualCenterCutHeight,
        m_actualUsingCenterCut,
        m_zoom, m_centerCutWidth, m_centerCutHeight, m_usingCenterCut,
        getWidth(), getHeight(), getMaxZoom());
}
int ZDvidDataSliceHelper::updateParam(ZStackViewParam *param)
{
  int maxZoomLevel = getMaxZoom();
  if (maxZoomLevel < 3) {
    int width = param->getViewPort().width();
    int height = param->getViewPort().height();
    if (validateSize(&width, &height)) {
      param->resize(width, height);
    }
  }

  return maxZoomLevel;
}
void ZDvidDataSliceHelper::inferUpdatePolicy(neutube::EAxis axis)
{
  if (getMaxZoom() == 0) {
    if (axis == neutube::EAxis::ARB) {
      setUpdatePolicy(flyem::EDataSliceUpdatePolicy::HIDDEN);
    } else {
      setUpdatePolicy(flyem::EDataSliceUpdatePolicy::SMALL);
    }
  } else {
    if (axis == neutube::EAxis::ARB) {
      setUpdatePolicy(getPreferredUpdatePolicy());
    } else {
      setUpdatePolicy(flyem::EDataSliceUpdatePolicy::LOWRES);
    }
  }
}
ZStackViewParam ZDvidDataSliceHelper::getValidViewParam(
    const ZStackViewParam &viewParam) const
{
  ZStackViewParam newViewParam = viewParam;

  int maxZoomLevel = getMaxZoom();
  if (maxZoomLevel < 3) {
    int width = viewParam.getViewPort().width();
    int height = viewParam.getViewPort().height();
    if (validateSize(&width, &height)) {
      newViewParam.resize(width, height);
    }
  }

  return newViewParam;
}
Exemple #10
0
CameraOptions Map::cameraForLatLngs(const std::vector<LatLng>& latLngs, const EdgeInsets& padding) {
    CameraOptions options;
    if (latLngs.empty()) {
        return options;
    }

    // Calculate the bounds of the possibly rotated shape with respect to the viewport.
    PrecisionPoint nePixel = {-INFINITY, -INFINITY};
    PrecisionPoint swPixel = {INFINITY, INFINITY};
    for (LatLng latLng : latLngs) {
        PrecisionPoint pixel = pixelForLatLng(latLng);
        swPixel.x = std::min(swPixel.x, pixel.x);
        nePixel.x = std::max(nePixel.x, pixel.x);
        swPixel.y = std::min(swPixel.y, pixel.y);
        nePixel.y = std::max(nePixel.y, pixel.y);
    }
    double width = nePixel.x - swPixel.x;
    double height = nePixel.y - swPixel.y;

    // Calculate the zoom level.
    double scaleX = (getWidth() - padding.left - padding.right) / width;
    double scaleY = (getHeight() - padding.top - padding.bottom) / height;
    double minScale = ::fmin(scaleX, scaleY);
    double zoom = ::log2(getScale() * minScale);
    zoom = ::fmax(::fmin(zoom, getMaxZoom()), getMinZoom());

    // Calculate the center point of a virtual bounds that is extended in all directions by padding.
    PrecisionPoint paddedNEPixel = {
        nePixel.x + padding.right / minScale,
        nePixel.y + padding.top / minScale,
    };
    PrecisionPoint paddedSWPixel = {
        swPixel.x - padding.left / minScale,
        swPixel.y - padding.bottom / minScale,
    };
    PrecisionPoint centerPixel = {
        (paddedNEPixel.x + paddedSWPixel.x) / 2,
        (paddedNEPixel.y + paddedSWPixel.y) / 2,
    };

    options.center = latLngForPixel(centerPixel);
    options.zoom = zoom;
    return options;
}
bool OsmAnd::ImageMapLayerProvider::obtainData(
    const IMapDataProvider::Request& request_,
    std::shared_ptr<IMapDataProvider::Data>& outData,
    std::shared_ptr<Metric>* const pOutMetric /*= nullptr*/)
{
    const auto& request = MapDataProviderHelpers::castRequest<Request>(request_);
    if (pOutMetric)
        pOutMetric->reset();

    // Check provider can supply this zoom level
    if (request.zoom > getMaxZoom() || request.zoom < getMinZoom())
    {
        outData.reset();
        return true;
    }

    if (!supportsNaturalObtainData())
        return MapDataProviderHelpers::nonNaturalObtainData(this, request, outData, pOutMetric);

    // Obtain image data
    const auto image = obtainImage(request);
    if (image.isNull())
    {
        outData.reset();
        return true;
    }

    // Decode image data
    std::shared_ptr<SkBitmap> bitmap(new SkBitmap());
    SkMemoryStream imageStream(image.constData(), image.length(), false);
    if (!SkImageDecoder::DecodeStream(&imageStream, bitmap.get(), SkColorType::kUnknown_SkColorType, SkImageDecoder::kDecodePixels_Mode))
        return false;

    // Return tile
    outData.reset(new IRasterMapLayerProvider::Data(
        request.tileId,
        request.zoom,
        getAlphaChannelPresence(),
        getTileDensityFactor(),
        bitmap));
    return true;
}
Exemple #12
0
CameraOptions Map::cameraForLatLngs(std::vector<LatLng> latLngs, EdgeInsets padding) {
    CameraOptions options;
    if (latLngs.empty()) {
        return options;
    }

    // Calculate the bounds of the possibly rotated shape with respect to the viewport.
    vec2<> nePixel = {-INFINITY, -INFINITY};
    vec2<> swPixel = {INFINITY, INFINITY};
    for (LatLng latLng : latLngs) {
        vec2<> pixel = pixelForLatLng(latLng);
        swPixel.x = std::min(swPixel.x, pixel.x);
        nePixel.x = std::max(nePixel.x, pixel.x);
        swPixel.y = std::min(swPixel.y, pixel.y);
        nePixel.y = std::max(nePixel.y, pixel.y);
    }
    vec2<> size = nePixel - swPixel;

    // Calculate the zoom level.
    double scaleX = (getWidth() - padding.left - padding.right) / size.x;
    double scaleY = (getHeight() - padding.top - padding.bottom) / size.y;
    double minScale = ::fmin(scaleX, scaleY);
    double zoom = ::log2(getScale() * minScale);
    zoom = ::fmax(::fmin(zoom, getMaxZoom()), getMinZoom());

    // Calculate the center point of a virtual bounds that is extended in all directions by padding.
    vec2<> paddedNEPixel = {
        nePixel.x + padding.right / minScale,
        nePixel.y + padding.top / minScale,
    };
    vec2<> paddedSWPixel = {
        swPixel.x - padding.left / minScale,
        swPixel.y - padding.bottom / minScale,
    };
    vec2<> centerPixel = (paddedNEPixel + paddedSWPixel) * 0.5;
    LatLng centerLatLng = latLngForPixel(centerPixel);

    options.center = centerLatLng;
    options.zoom = zoom;
    return options;
}
void Map::fitBounds(AnnotationSegment segment, EdgeInsets padding, Duration duration) {
    if (segment.empty()) {
        return;
    }
    
    // Calculate the bounds of the possibly rotated shape with respect to the viewport.
    vec2<> nePixel = {-INFINITY, -INFINITY};
    vec2<> swPixel = {INFINITY, INFINITY};
    for (LatLng latLng : segment) {
        vec2<> pixel = pixelForLatLng(latLng);
        swPixel.x = std::min(swPixel.x, pixel.x);
        nePixel.x = std::max(nePixel.x, pixel.x);
        swPixel.y = std::min(swPixel.y, pixel.y);
        nePixel.y = std::max(nePixel.y, pixel.y);
    }
    vec2<> size = nePixel - swPixel;

    // Calculate the zoom level.
    double scaleX = (getWidth() - padding.left - padding.right) / size.x;
    double scaleY = (getHeight() - padding.top - padding.bottom) / size.y;
    double minScale = std::fmin(scaleX, scaleY);
    double zoom = std::log2(getScale() * minScale);
    zoom = std::fmax(std::fmin(zoom, getMaxZoom()), getMinZoom());

    // Calculate the center point of a virtual bounds that is extended in all directions by padding.
    vec2<> paddedNEPixel = {
        nePixel.x + padding.right / minScale,
        nePixel.y + padding.top / minScale,
    };
    vec2<> paddedSWPixel = {
        swPixel.x - padding.left / minScale,
        swPixel.y - padding.bottom / minScale,
    };
    vec2<> centerPixel = (paddedNEPixel + paddedSWPixel) * 0.5;
    LatLng centerLatLng = latLngForPixel(centerPixel);

    setLatLngZoom(centerLatLng, zoom, duration);
}
std::vector<uint32_t> Map::getAnnotationsInBounds(const LatLngBounds& bounds, const AnnotationType& type) {
    return data->annotationManager.getAnnotationsInBounds(bounds, getMaxZoom(), type);
}
void Map::removeAnnotations(const std::vector<uint32_t>& annotations) {
    auto result = data->annotationManager.removeAnnotations(annotations, getMaxZoom());
    context->invoke(&MapContext::updateAnnotationTiles, result);
}
AnnotationIDs Map::addShapeAnnotations(const std::vector<ShapeAnnotation>& annotations) {
    auto result = data->annotationManager.addShapeAnnotations(annotations, getMaxZoom());
    context->invoke(&MapContext::updateAnnotationTiles, result.first);
    return result.second;
}
void TransformState::setMinZoom(const double minZoom) {
    if (minZoom <= getMaxZoom()) {
        min_scale = zoomScale(util::clamp(minZoom, util::MIN_ZOOM, util::MAX_ZOOM));
    }
}
Exemple #18
0
AnnotationIDs Map::addShapeAnnotations(const std::vector<ShapeAnnotation>& annotations) {
    auto result = data->getAnnotationManager()->addShapeAnnotations(annotations, getMaxZoom());
    update(Update::Annotations);
    return result;
}