strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/drawinglayer/source/primitive2d/gridprimitive2d.cxx
Noel Grandin 3b83c6ac80 make BufferedDecompositionPrimitive2D store a Primitive2DReference.. 
.. instead of a Primitive2DContainer.

The container very frequently contains only a single item, since
the decomposition method often sticks only a single top-level node
in there, so it turns out to be a net loss overall, memory
consumption-wise.

Also, if we return a single Primitive2DReference from
a BufferedDecomposition, that maximises the sharing of
data between the BufferedDecomposition objects at the
bottom of the decomposed tree, and objects higher up.

Change-Id: Iaf272e60e2997299cc35a1bd209c51b6b79e9a8b
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/162976
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
2024-02-12 11:36:05 +01:00

340 lines
14 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <drawinglayer/primitive2d/gridprimitive2d.hxx>
#include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx>
#include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx>
#include <drawinglayer/primitive2d/groupprimitive2d.hxx>
#include <drawinglayer/geometry/viewinformation2d.hxx>
#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>
#include <utility>
using namespace com::sun::star;
namespace drawinglayer::primitive2d
{
Primitive2DReference GridPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
{
if(!(!rViewInformation.getViewport().isEmpty() && getWidth() > 0.0 && getHeight() > 0.0))
return nullptr;
// decompose grid matrix to get logic size
basegfx::B2DVector aScale, aTranslate;
double fRotate, fShearX;
getTransform().decompose(aScale, aTranslate, fRotate, fShearX);
// create grid matrix which transforms from scaled logic to view
basegfx::B2DHomMatrix aRST(basegfx::utils::createShearXRotateTranslateB2DHomMatrix(
fShearX, fRotate, aTranslate.getX(), aTranslate.getY()));
aRST *= rViewInformation.getObjectToViewTransformation();
// get step widths
double fStepX(getWidth());
double fStepY(getHeight());
const double fMinimalStep(10.0);
// guarantee a step width of 10.0
if(basegfx::fTools::less(fStepX, fMinimalStep))
{
fStepX = fMinimalStep;
}
if(basegfx::fTools::less(fStepY, fMinimalStep))
{
fStepY = fMinimalStep;
}
// get relative distances in view coordinates
double fViewStepX((rViewInformation.getObjectToViewTransformation() * basegfx::B2DVector(fStepX, 0.0)).getLength());
double fViewStepY((rViewInformation.getObjectToViewTransformation() * basegfx::B2DVector(0.0, fStepY)).getLength());
double fSmallStepX(1.0), fViewSmallStepX(1.0), fSmallStepY(1.0), fViewSmallStepY(1.0);
sal_uInt32 nSmallStepsX(0), nSmallStepsY(0);
// setup subdivisions
if(getSubdivisionsX())
{
fSmallStepX = fStepX / getSubdivisionsX();
fViewSmallStepX = fViewStepX / getSubdivisionsX();
}
if(getSubdivisionsY())
{
fSmallStepY = fStepY / getSubdivisionsY();
fViewSmallStepY = fViewStepY / getSubdivisionsY();
}
// correct step width
while(fViewStepX < getSmallestViewDistance())
{
fViewStepX *= 2.0;
fStepX *= 2.0;
}
while(fViewStepY < getSmallestViewDistance())
{
fViewStepY *= 2.0;
fStepY *= 2.0;
}
// correct small step width
if(getSubdivisionsX())
{
while(fViewSmallStepX < getSmallestSubdivisionViewDistance())
{
fViewSmallStepX *= 2.0;
fSmallStepX *= 2.0;
}
nSmallStepsX = static_cast<sal_uInt32>(fStepX / fSmallStepX);
}
if(getSubdivisionsY())
{
while(fViewSmallStepY < getSmallestSubdivisionViewDistance())
{
fViewSmallStepY *= 2.0;
fSmallStepY *= 2.0;
}
nSmallStepsY = static_cast<sal_uInt32>(fStepY / fSmallStepY);
}
// calculate extended viewport in which grid points may lie at all
basegfx::B2DRange aExtendedViewport;
if(rViewInformation.getDiscreteViewport().isEmpty())
{
// not set, use logic size to travel over all potential grid points
aExtendedViewport = basegfx::B2DRange(0.0, 0.0, aScale.getX(), aScale.getY());
}
else
{
// transform unit range to discrete view
aExtendedViewport = basegfx::B2DRange(0.0, 0.0, 1.0, 1.0);
basegfx::B2DHomMatrix aTrans(rViewInformation.getObjectToViewTransformation() * getTransform());
aExtendedViewport.transform(aTrans);
// intersect with visible part
aExtendedViewport.intersect(rViewInformation.getDiscreteViewport());
if(!aExtendedViewport.isEmpty())
{
// convert back and apply scale
aTrans.invert();
aTrans.scale(aScale.getX(), aScale.getY());
aExtendedViewport.transform(aTrans);
// crop start/end in X/Y to multiples of logical step width
const double fHalfCrossSize((rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(3.0, 0.0)).getLength());
const double fMinX(floor((aExtendedViewport.getMinX() - fHalfCrossSize) / fStepX) * fStepX);
const double fMaxX(ceil((aExtendedViewport.getMaxX() + fHalfCrossSize) / fStepX) * fStepX);
const double fMinY(floor((aExtendedViewport.getMinY() - fHalfCrossSize) / fStepY) * fStepY);
const double fMaxY(ceil((aExtendedViewport.getMaxY() + fHalfCrossSize) / fStepY) * fStepY);
// put to aExtendedViewport and crop on object logic size
aExtendedViewport = basegfx::B2DRange(
std::max(fMinX, 0.0),
std::max(fMinY, 0.0),
std::min(fMaxX, aScale.getX()),
std::min(fMaxY, aScale.getY()));
}
}
if(aExtendedViewport.isEmpty())
return nullptr;
// prepare point vectors for point and cross markers
std::vector< basegfx::B2DPoint > aPositionsPoint;
std::vector< basegfx::B2DPoint > aPositionsCross;
for(double fX(aExtendedViewport.getMinX()); fX < aExtendedViewport.getMaxX(); fX += fStepX)
{
const bool bXZero(basegfx::fTools::equalZero(fX));
for(double fY(aExtendedViewport.getMinY()); fY < aExtendedViewport.getMaxY(); fY += fStepY)
{
const bool bYZero(basegfx::fTools::equalZero(fY));
if(!bXZero && !bYZero)
{
// get discrete position and test against 3x3 area surrounding it
// since it's a cross
const double fHalfCrossSize(3.0 * 0.5);
const basegfx::B2DPoint aViewPos(aRST * basegfx::B2DPoint(fX, fY));
const basegfx::B2DRange aDiscreteRangeCross(
aViewPos.getX() - fHalfCrossSize, aViewPos.getY() - fHalfCrossSize,
aViewPos.getX() + fHalfCrossSize, aViewPos.getY() + fHalfCrossSize);
if(rViewInformation.getDiscreteViewport().overlaps(aDiscreteRangeCross))
{
const basegfx::B2DPoint aLogicPos(rViewInformation.getInverseObjectToViewTransformation() * aViewPos);
aPositionsCross.push_back(aLogicPos);
}
}
if(getSubdivisionsX() && !bYZero)
{
double fF(fX + fSmallStepX);
for(sal_uInt32 a(1); a < nSmallStepsX && fF < aExtendedViewport.getMaxX(); a++, fF += fSmallStepX)
{
const basegfx::B2DPoint aViewPos(aRST * basegfx::B2DPoint(fF, fY));
if(rViewInformation.getDiscreteViewport().isInside(aViewPos))
{
const basegfx::B2DPoint aLogicPos(rViewInformation.getInverseObjectToViewTransformation() * aViewPos);
aPositionsPoint.push_back(aLogicPos);
}
}
}
if(getSubdivisionsY() && !bXZero)
{
double fF(fY + fSmallStepY);
for(sal_uInt32 a(1); a < nSmallStepsY && fF < aExtendedViewport.getMaxY(); a++, fF += fSmallStepY)
{
const basegfx::B2DPoint aViewPos(aRST * basegfx::B2DPoint(fX, fF));
if(rViewInformation.getDiscreteViewport().isInside(aViewPos))
{
const basegfx::B2DPoint aLogicPos(rViewInformation.getInverseObjectToViewTransformation() * aViewPos);
aPositionsPoint.push_back(aLogicPos);
}
}
}
}
}
// prepare return value
const sal_uInt32 nCountPoint(aPositionsPoint.size());
const sal_uInt32 nCountCross(aPositionsCross.size());
// add PointArrayPrimitive2D if point markers were added
Primitive2DContainer aContainer;
if(nCountPoint)
{
aContainer.push_back(new PointArrayPrimitive2D(std::move(aPositionsPoint), getBColor()));
}
// add MarkerArrayPrimitive2D if cross markers were added
if(!nCountCross)
return new GroupPrimitive2D(std::move(aContainer));
if(!getSubdivisionsX() && !getSubdivisionsY())
{
// no subdivisions, so fall back to points at grid positions, no need to
// visualize a difference between divisions and sub-divisions
aContainer.push_back(new PointArrayPrimitive2D(std::move(aPositionsCross), getBColor()));
}
else
{
aContainer.push_back(new MarkerArrayPrimitive2D(std::move(aPositionsCross), getCrossMarker()));
}
return new GroupPrimitive2D(std::move(aContainer));
}
GridPrimitive2D::GridPrimitive2D(
basegfx::B2DHomMatrix aTransform,
double fWidth,
double fHeight,
double fSmallestViewDistance,
double fSmallestSubdivisionViewDistance,
sal_uInt32 nSubdivisionsX,
sal_uInt32 nSubdivisionsY,
const basegfx::BColor& rBColor,
const BitmapEx& rCrossMarker)
: maTransform(std::move(aTransform)),
mfWidth(fWidth),
mfHeight(fHeight),
mfSmallestViewDistance(fSmallestViewDistance),
mfSmallestSubdivisionViewDistance(fSmallestSubdivisionViewDistance),
mnSubdivisionsX(nSubdivisionsX),
mnSubdivisionsY(nSubdivisionsY),
maBColor(rBColor),
maCrossMarker(rCrossMarker)
{
}
bool GridPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
{
if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
{
const GridPrimitive2D& rCompare = static_cast<const GridPrimitive2D&>(rPrimitive);
return (getTransform() == rCompare.getTransform()
&& getWidth() == rCompare.getWidth()
&& getHeight() == rCompare.getHeight()
&& getSmallestViewDistance() == rCompare.getSmallestViewDistance()
&& getSmallestSubdivisionViewDistance() == rCompare.getSmallestSubdivisionViewDistance()
&& getSubdivisionsX() == rCompare.getSubdivisionsX()
&& getSubdivisionsY() == rCompare.getSubdivisionsY()
&& getBColor() == rCompare.getBColor()
&& getCrossMarker() == rCompare.getCrossMarker());
}
return false;
}
basegfx::B2DRange GridPrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
{
// get object's range
basegfx::B2DRange aUnitRange(0.0, 0.0, 1.0, 1.0);
aUnitRange.transform(getTransform());
// intersect with visible part
aUnitRange.intersect(rViewInformation.getViewport());
return aUnitRange;
}
void GridPrimitive2D::get2DDecomposition(Primitive2DDecompositionVisitor& rVisitor, const geometry::ViewInformation2D& rViewInformation) const
{
if(getBuffered2DDecomposition())
{
if(maLastViewport != rViewInformation.getViewport() || maLastObjectToViewTransformation != rViewInformation.getObjectToViewTransformation())
{
// conditions of last local decomposition have changed, delete
const_cast< GridPrimitive2D* >(this)->setBuffered2DDecomposition(nullptr);
}
}
if(!getBuffered2DDecomposition())
{
// remember ViewRange and ViewTransformation
const_cast< GridPrimitive2D* >(this)->maLastObjectToViewTransformation = rViewInformation.getObjectToViewTransformation();
const_cast< GridPrimitive2D* >(this)->maLastViewport = rViewInformation.getViewport();
}
// use parent implementation
BufferedDecompositionPrimitive2D::get2DDecomposition(rVisitor, rViewInformation);
}
// provide unique ID
sal_uInt32 GridPrimitive2D::getPrimitive2DID() const
{
return PRIMITIVE2D_ID_GRIDPRIMITIVE2D;
}
} // end of namespace
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink