536 lines
14 KiB
C++
536 lines
14 KiB
C++
/****************************************************************************
|
|
**
|
|
** This file is part of the LibreCAD project, a 2D CAD program
|
|
**
|
|
** Copyright (C) 2010 R. van Twisk (librecad@rvt.dds.nl)
|
|
** Copyright (C) 2001-2003 RibbonSoft. All rights reserved.
|
|
**
|
|
**
|
|
** This file may be distributed and/or modified under the terms of the
|
|
** GNU General Public License version 2 as published by the Free Software
|
|
** Foundation and appearing in the file gpl-2.0.txt included in the
|
|
** packaging of this file.
|
|
**
|
|
** This program is distributed in the hope that it will be useful,
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
** GNU General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License
|
|
** along with this program; if not, write to the Free Software
|
|
** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
**
|
|
** This copyright notice MUST APPEAR in all copies of the script!
|
|
**
|
|
**********************************************************************/
|
|
#include<cmath>
|
|
#include<QString>
|
|
#include "rs_grid.h"
|
|
#include "rs_graphicview.h"
|
|
#include "rs_units.h"
|
|
#include "rs_graphic.h"
|
|
#include "rs_settings.h"
|
|
#include "rs_math.h"
|
|
#include "lc_rect.h"
|
|
#include "rs_debug.h"
|
|
|
|
#ifdef EMU_C99
|
|
#include "emu_c99.h"
|
|
#endif
|
|
|
|
namespace {
|
|
//maximum number grid points to draw, for performance consideration
|
|
const int maxGridPoints=1000000;
|
|
//minimum grid width to consider
|
|
const double minimumGridWidth=1.0e-8;
|
|
}
|
|
|
|
/**
|
|
* Constructor.
|
|
*/
|
|
RS_Grid::RS_Grid(RS_GraphicView* graphicView)
|
|
:graphicView(graphicView)
|
|
,baseGrid(false)
|
|
{}
|
|
|
|
/**
|
|
* find the closest grid point
|
|
*@return the closest grid to given point
|
|
*@coord: the given point
|
|
*/
|
|
RS_Vector RS_Grid::snapGrid(const RS_Vector& coord) const {
|
|
if( cellV.x<RS_TOLERANCE || cellV.y<RS_TOLERANCE) return coord;
|
|
RS_Vector vp(coord-baseGrid);
|
|
if(isometric){
|
|
//use remainder instead of fmod to locate the left-bottom corner for both positive and negative displacement
|
|
RS_Vector vp1( vp-RS_Vector( remainder(vp.x-0.5*cellV.x,cellV.x)+0.5*cellV.x, remainder(vp.y-0.5*cellV.y,cellV.y)+0.5*cellV.y));
|
|
RS_VectorSolutions sol({vp1,vp1+cellV,vp1+cellV*0.5, vp1+RS_Vector(cellV.x,0.), vp1+RS_Vector(0.,cellV.y)});
|
|
vp1=sol.getClosest(vp);
|
|
return baseGrid+vp1;
|
|
|
|
}else{
|
|
return baseGrid+vp-RS_Vector(remainder(vp.x,cellV.x),remainder(vp.y,cellV.y));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates the grid point array.
|
|
*/
|
|
void RS_Grid::updatePointArray() {
|
|
if (!graphicView->isGridOn()) return;
|
|
|
|
RS_Graphic* graphic = graphicView->getGraphic();
|
|
|
|
// auto scale grid?
|
|
RS_SETTINGS->beginGroup("/Appearance");
|
|
bool scaleGrid = (bool)RS_SETTINGS->readNumEntry("/ScaleGrid", 1);
|
|
// get grid setting
|
|
RS_Vector userGrid;
|
|
if (graphic) {
|
|
//$ISOMETRICGRID == $SNAPSTYLE
|
|
isometric = static_cast<bool>(graphic->getVariableInt("$SNAPSTYLE",0));
|
|
crosshairType=graphic->getCrosshairType();
|
|
userGrid = graphic->getVariableVector("$GRIDUNIT",
|
|
RS_Vector(-1.0, -1.0));
|
|
}else {
|
|
isometric = (bool)RS_SETTINGS->readNumEntry("/IsometricGrid", 0);
|
|
crosshairType=static_cast<RS2::CrosshairType>(RS_SETTINGS->readNumEntry("/CrosshairType",0));
|
|
userGrid.x = RS_SETTINGS->readEntry("/GridSpacingX",QString("-1")).toDouble();
|
|
userGrid.y = RS_SETTINGS->readEntry("/GridSpacingY",QString("-1")).toDouble();
|
|
}
|
|
int minGridSpacing = RS_SETTINGS->readNumEntry("/MinGridSpacing", 10);
|
|
RS_SETTINGS->endGroup();
|
|
|
|
// std::cout<<"Grid userGrid="<<userGrid<<std::endl;
|
|
|
|
pt.clear();
|
|
metaX.clear();
|
|
metaY.clear();
|
|
|
|
// RS_DEBUG->print("RS_Grid::update: 001");
|
|
|
|
// find out unit:
|
|
RS2::Unit unit = RS2::None;
|
|
RS2::LinearFormat format = RS2::Decimal;
|
|
if (graphic) {
|
|
unit = graphic->getUnit();
|
|
format = graphic->getLinearFormat();
|
|
}
|
|
|
|
RS_Vector gridWidth;
|
|
// RS_Vector metaGridWidth;
|
|
|
|
// RS_DEBUG->print("RS_Grid::update: 002");
|
|
|
|
// init grid spacing:
|
|
// metric grid:
|
|
if (RS_Units::isMetric(unit) || unit==RS2::None ||
|
|
format==RS2::Decimal || format==RS2::Engineering) {
|
|
//metric grid
|
|
gridWidth = getMetricGridWidth(userGrid, scaleGrid, minGridSpacing);
|
|
|
|
}else {
|
|
// imperial grid:
|
|
gridWidth = getImperialGridWidth(userGrid, scaleGrid, minGridSpacing);
|
|
|
|
}
|
|
|
|
// RS_DEBUG->print("RS_Grid::update: 013");
|
|
|
|
// for grid info:
|
|
spacing = gridWidth.x;
|
|
metaSpacing = metaGridWidth.x;
|
|
//std::cout<<"Grid spacing="<<spacing<<std::endl;
|
|
//std::cout<<"Grid metaSpacing="<<metaSpacing<<std::endl;
|
|
|
|
if (gridWidth.x>minimumGridWidth && gridWidth.y>minimumGridWidth &&
|
|
graphicView->toGuiDX(gridWidth.x)>2 &&
|
|
graphicView->toGuiDY(gridWidth.y)>2) {
|
|
|
|
// find grid boundaries
|
|
double left = (int)(graphicView->toGraphX(0) / gridWidth.x)
|
|
* gridWidth.x;
|
|
double right = (int)(graphicView->toGraphX(graphicView->getWidth()) /
|
|
gridWidth.x) * gridWidth.x;
|
|
double top = (int)(graphicView->toGraphY(0) /
|
|
gridWidth.y) * gridWidth.y;
|
|
double bottom =
|
|
(int)(graphicView->toGraphY(graphicView->getHeight()) /
|
|
gridWidth.y) * gridWidth.y;
|
|
|
|
|
|
left -= gridWidth.x;
|
|
right += gridWidth.x;
|
|
top += gridWidth.y;
|
|
bottom -= gridWidth.y;
|
|
|
|
//top/bottom is reversed with RectF definition
|
|
LC_Rect const rect{{left, bottom}, {right, top}};
|
|
|
|
// populate grid points and metaGrid line positions: pts, metaX, metaY
|
|
if(isometric){
|
|
createIsometricGrid(rect, gridWidth);
|
|
}else{
|
|
createOrthogonalGrid(rect, gridWidth);
|
|
|
|
}
|
|
|
|
// RS_DEBUG->print("RS_Grid::update: 015");
|
|
}
|
|
|
|
// RS_DEBUG->print("RS_Grid::update: OK");
|
|
}
|
|
|
|
|
|
RS_Vector RS_Grid::getMetricGridWidth(RS_Vector const& userGrid, bool scaleGrid, int minGridSpacing)
|
|
{
|
|
RS_Vector gridWidth;
|
|
|
|
if (userGrid.x>0.0) {
|
|
gridWidth.x = userGrid.x;
|
|
}
|
|
else {
|
|
gridWidth.x = minimumGridWidth;
|
|
}
|
|
|
|
if (userGrid.y>0.0) {
|
|
gridWidth.y = userGrid.y;
|
|
}
|
|
else {
|
|
gridWidth.y = minimumGridWidth;
|
|
}
|
|
|
|
// RS_DEBUG->print("RS_Grid::update: 003");
|
|
|
|
// auto scale grid
|
|
//scale grid by drawing setting as well, bug#3416862
|
|
// std::cout<<"RS_Grid::updatePointArray(): userGrid="<<userGrid<<std::endl;
|
|
if (scaleGrid|| userGrid.x<=minimumGridWidth || userGrid.y<=minimumGridWidth) {
|
|
if(scaleGrid || userGrid.x<=minimumGridWidth) {
|
|
while (graphicView->toGuiDX(gridWidth.x)<minGridSpacing) {
|
|
gridWidth.x*=10;
|
|
}
|
|
}
|
|
if(scaleGrid || userGrid.y<=minimumGridWidth) {
|
|
while (graphicView->toGuiDY(gridWidth.y)<minGridSpacing) {
|
|
gridWidth.y*=10;
|
|
}
|
|
}
|
|
}
|
|
// std::cout<<"RS_Grid::updatePointArray(): gridWidth="<<gridWidth<<std::endl;
|
|
metaGridWidth.x = gridWidth.x*10;
|
|
metaGridWidth.y = gridWidth.y*10;
|
|
|
|
// RS_DEBUG->print("RS_Grid::update: 004");
|
|
return gridWidth;
|
|
}
|
|
|
|
RS_Vector RS_Grid::getImperialGridWidth(RS_Vector const& userGrid, bool scaleGrid, int minGridSpacing)
|
|
{
|
|
RS_Vector gridWidth;
|
|
// RS_DEBUG->print("RS_Grid::update: 005");
|
|
|
|
if (userGrid.x>0.0) {
|
|
gridWidth.x = userGrid.x;
|
|
}
|
|
else {
|
|
gridWidth.x = 1.0/1024.0;
|
|
}
|
|
|
|
if (userGrid.y>0.0) {
|
|
gridWidth.y = userGrid.y;
|
|
}
|
|
else {
|
|
gridWidth.y = 1.0/1024.0;
|
|
}
|
|
// RS_DEBUG->print("RS_Grid::update: 006");
|
|
|
|
RS2::Unit unit = RS2::None;
|
|
// RS2::LinearFormat format = RS2::Decimal;
|
|
RS_Graphic* graphic = graphicView->getGraphic();
|
|
|
|
if (graphic) {
|
|
unit = graphic->getUnit();
|
|
// format = graphic->getLinearFormat();
|
|
}
|
|
|
|
if (unit==RS2::Inch) {
|
|
// RS_DEBUG->print("RS_Grid::update: 007");
|
|
|
|
// auto scale grid
|
|
//scale grid by drawing setting as well, bug#3416862
|
|
if (scaleGrid|| userGrid.x<=minimumGridWidth || userGrid.y<=minimumGridWidth) {
|
|
if(scaleGrid || userGrid.x<=minimumGridWidth) {
|
|
while (graphicView->toGuiDX(gridWidth.x)<minGridSpacing) {
|
|
if (RS_Math::round(gridWidth.x)>=36) {
|
|
gridWidth.x*=2;
|
|
} else if (RS_Math::round(gridWidth.x)>=12) {
|
|
gridWidth.x*=3;
|
|
} else if (RS_Math::round(gridWidth.x)>=4) {
|
|
gridWidth.x*=3;
|
|
} else if (RS_Math::round(gridWidth.x)>=1) {
|
|
gridWidth.x*=2;
|
|
} else {
|
|
gridWidth.x*=2;
|
|
}
|
|
}
|
|
}
|
|
if(scaleGrid || userGrid.y<=minimumGridWidth) {
|
|
while (graphicView->toGuiDY(gridWidth.y)<minGridSpacing) {
|
|
if (RS_Math::round(gridWidth.y)>=36) {
|
|
gridWidth.y*=2;
|
|
} else if (RS_Math::round(gridWidth.y)>=12) {
|
|
gridWidth.y*=3;
|
|
} else if (RS_Math::round(gridWidth.y)>=4) {
|
|
gridWidth.y*=3;
|
|
} else if (RS_Math::round(gridWidth.y)>=1) {
|
|
gridWidth.y*=2;
|
|
} else {
|
|
gridWidth.y*=2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// RS_DEBUG->print("RS_Grid::update: 008");
|
|
|
|
// metagrid X shows inches..
|
|
metaGridWidth.x = 1.0;
|
|
|
|
if (graphicView->toGuiDX(metaGridWidth.x)<minGridSpacing*2) {
|
|
// .. or feet
|
|
metaGridWidth.x = 12.0;
|
|
|
|
// .. or yards
|
|
if (graphicView->toGuiDX(metaGridWidth.x)<minGridSpacing*2) {
|
|
metaGridWidth.x = 36.0;
|
|
|
|
// .. or miles (not really..)
|
|
//if (graphicView->toGuiDX(metaGridWidth.x)<20) {
|
|
// metaGridWidth.x = 63360.0;
|
|
//}
|
|
|
|
// .. or nothing
|
|
if (graphicView->toGuiDX(metaGridWidth.x)<minGridSpacing*2) {
|
|
metaGridWidth.x = -1.0;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// RS_DEBUG->print("RS_Grid::update: 009");
|
|
|
|
// metagrid Y shows inches..
|
|
metaGridWidth.y = 1.0;
|
|
|
|
if (graphicView->toGuiDY(metaGridWidth.y)<minGridSpacing*2) {
|
|
// .. or feet
|
|
metaGridWidth.y = 12.0;
|
|
|
|
// .. or yards
|
|
if (graphicView->toGuiDY(metaGridWidth.y)<minGridSpacing*2) {
|
|
metaGridWidth.y = 36.0;
|
|
|
|
// .. or miles (not really..)
|
|
//if (graphicView->toGuiDY(metaGridWidth.y)<20) {
|
|
// metaGridWidth.y = 63360.0;
|
|
//}
|
|
|
|
// .. or nothing
|
|
if (graphicView->toGuiDY(metaGridWidth.y)<minGridSpacing*2) {
|
|
metaGridWidth.y = -1.0;
|
|
}
|
|
}
|
|
}
|
|
// RS_DEBUG->print("RS_Grid::update: 010");
|
|
} else {
|
|
// RS_DEBUG->print("RS_Grid::update: 011");
|
|
if (scaleGrid) {
|
|
while (graphicView->toGuiDX(gridWidth.x)<minGridSpacing) {
|
|
gridWidth.x*=2;
|
|
}
|
|
metaGridWidth.x = -1.0;
|
|
|
|
while (graphicView->toGuiDY(gridWidth.y)<minGridSpacing) {
|
|
gridWidth.y*=2;
|
|
}
|
|
metaGridWidth.y = -1.0;
|
|
}
|
|
// RS_DEBUG->print("RS_Grid::update: 012");
|
|
}
|
|
//gridWidth.y = gridWidth.x;
|
|
//metaGridWidth.y = metaGridWidth.x;
|
|
return gridWidth;
|
|
}
|
|
|
|
|
|
void RS_Grid::createOrthogonalGrid(LC_Rect const& rect, RS_Vector const& gridWidth)
|
|
{
|
|
double const left=rect.minP().x;
|
|
double const right=rect.maxP().x;
|
|
//top/bottom reversed
|
|
double const top=rect.maxP().y;
|
|
double const bottom=rect.minP().y;
|
|
|
|
cellV.set(fabs(gridWidth.x),fabs(gridWidth.y));
|
|
int numberX = (RS_Math::round((right-left) / gridWidth.x) + 1);
|
|
int numberY = (RS_Math::round((top-bottom) / gridWidth.y) + 1);
|
|
int number = numberX*numberY;
|
|
//todo, fix baseGrid for orthogonal grid
|
|
baseGrid.set(left,bottom);
|
|
|
|
// create grid array:
|
|
|
|
if (number<=0 || number>maxGridPoints) return;
|
|
|
|
pt.resize(number);
|
|
|
|
int i=0;
|
|
RS_Vector bp0(baseGrid);
|
|
for (int y=0; y<numberY; ++y) {
|
|
RS_Vector bp1(bp0);
|
|
for (int x=0; x<numberX; ++x) {
|
|
pt[i++] = bp1;
|
|
bp1.x += gridWidth.x;
|
|
}
|
|
bp0.y += gridWidth.y;
|
|
}
|
|
// find meta grid boundaries
|
|
if (metaGridWidth.x>minimumGridWidth && metaGridWidth.y>minimumGridWidth &&
|
|
graphicView->toGuiDX(metaGridWidth.x)>2 &&
|
|
graphicView->toGuiDY(metaGridWidth.y)>2) {
|
|
|
|
double mleft = (int)(graphicView->toGraphX(0) /
|
|
metaGridWidth.x) * metaGridWidth.x;
|
|
double mright = (int)(graphicView->toGraphX(graphicView->getWidth()) /
|
|
metaGridWidth.x) * metaGridWidth.x;
|
|
double mtop = (int)(graphicView->toGraphY(0) /
|
|
metaGridWidth.y) * metaGridWidth.y;
|
|
double mbottom = (int)(graphicView->toGraphY(graphicView->getHeight()) /
|
|
metaGridWidth.y) * metaGridWidth.y;
|
|
|
|
mleft -= metaGridWidth.x;
|
|
mright += metaGridWidth.x;
|
|
mtop += metaGridWidth.y;
|
|
mbottom -= metaGridWidth.y;
|
|
|
|
// calculate number of visible meta grid lines:
|
|
int numMetaX = (RS_Math::round((mright-mleft) / metaGridWidth.x) + 1);
|
|
int numMetaY = (RS_Math::round((mtop-mbottom) / metaGridWidth.y) + 1);
|
|
|
|
if (numMetaX<=0 || numMetaY<=0) return;
|
|
// create meta grid arrays:
|
|
metaX.resize(numMetaX);
|
|
metaY.resize(numMetaY);
|
|
|
|
int i=0;
|
|
for (int x=0; x<numMetaX; ++x) {
|
|
metaX[i++] = mleft+x*metaGridWidth.x;
|
|
}
|
|
i=0;
|
|
for (int y=0; y<numMetaY; ++y) {
|
|
metaY[i++] = mbottom+y*metaGridWidth.y;
|
|
}
|
|
}
|
|
}
|
|
|
|
void RS_Grid::createIsometricGrid(LC_Rect const& rect, RS_Vector const& gridWidth)
|
|
{
|
|
double const left=rect.minP().x;
|
|
double const right=rect.maxP().x;
|
|
//top/bottom reversed
|
|
double const top=rect.maxP().y;
|
|
double const bottom=rect.minP().y;
|
|
int numberY = (RS_Math::round((top-bottom) / gridWidth.y) + 1);
|
|
double dx=sqrt(3.)*gridWidth.y;
|
|
cellV.set(fabs(dx),fabs(gridWidth.y));
|
|
double hdx=0.5*dx;
|
|
double hdy=0.5*gridWidth.y;
|
|
int numberX = (RS_Math::round((right-left) / dx) + 1);
|
|
int number = 2*numberX*numberY;
|
|
baseGrid.set(left+remainder(-left,dx),bottom+remainder(-bottom,fabs(gridWidth.y)));
|
|
|
|
if (number<=0 || number>maxGridPoints) return;
|
|
|
|
pt.resize(number);
|
|
|
|
int i=0;
|
|
RS_Vector bp0(baseGrid),dbp1(hdx,hdy);
|
|
for (int y=0; y<numberY; ++y) {
|
|
RS_Vector bp1(bp0);
|
|
for (int x=0; x<numberX; ++x) {
|
|
pt[i++] = bp1;
|
|
pt[i++] = bp1+dbp1;
|
|
bp1.x += dx;
|
|
}
|
|
bp0.y += gridWidth.y;
|
|
}
|
|
//find metaGrid
|
|
if (metaGridWidth.y>minimumGridWidth &&
|
|
graphicView->toGuiDY(metaGridWidth.y)>2) {
|
|
|
|
metaGridWidth.x=(metaGridWidth.x<0.)?-sqrt(3.)*fabs(metaGridWidth.y):sqrt(3.)*fabs(metaGridWidth.y);
|
|
RS_Vector baseMetaGrid(left+remainder(-left,metaGridWidth.x)-fabs(metaGridWidth.x),bottom+remainder(-bottom,metaGridWidth.y)-fabs(metaGridWidth.y));
|
|
|
|
// calculate number of visible meta grid lines:
|
|
int numMetaX = (RS_Math::round((right-left) / metaGridWidth.x) + 1);
|
|
int numMetaY = (RS_Math::round((top-bottom) / metaGridWidth.y) + 1);
|
|
|
|
if (numMetaX<=0 || numMetaY<=0) return;
|
|
// create meta grid arrays:
|
|
metaX.resize(numMetaX);
|
|
metaY.resize(numMetaY);
|
|
|
|
double x0(baseMetaGrid.x);
|
|
for (int i=0; i<numMetaX; x0 += metaGridWidth.x) {
|
|
metaX[i++] = x0;
|
|
}
|
|
x0=baseMetaGrid.y;
|
|
for (int i=0; i<numMetaY; x0 += metaGridWidth.y) {
|
|
metaY[i++] = x0;
|
|
}
|
|
}
|
|
}
|
|
|
|
QString RS_Grid::getInfo() const{
|
|
return QString("%1 / %2").arg(spacing).arg(metaSpacing);
|
|
}
|
|
|
|
std::vector<RS_Vector> const& RS_Grid::getPoints() const{
|
|
return pt;
|
|
}
|
|
|
|
std::vector<double> const& RS_Grid::getMetaX() const{
|
|
return metaX;
|
|
}
|
|
|
|
std::vector<double> const& RS_Grid::getMetaY() const{
|
|
return metaY;
|
|
}
|
|
|
|
bool RS_Grid::isIsometric() const{
|
|
return isometric;
|
|
}
|
|
|
|
void RS_Grid::setIsometric(bool b){
|
|
isometric=b;
|
|
}
|
|
|
|
RS_Vector RS_Grid::getMetaGridWidth() const {
|
|
return metaGridWidth;
|
|
}
|
|
|
|
RS_Vector const& RS_Grid::getCellVector() const
|
|
{
|
|
return cellV;
|
|
}
|
|
|
|
void RS_Grid::setCrosshairType(RS2::CrosshairType chType){
|
|
crosshairType=chType;
|
|
}
|
|
RS2::CrosshairType RS_Grid::getCrosshairType() const{
|
|
return crosshairType;
|
|
}
|
|
|
|
// EOF
|