kotschak/qelectrotech-source-mirror
0
0
Fork 0
mirror of https://github.com/qelectrotech/qelectrotech-source-mirror.git synced 2025-12-17 20:50:34 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert r3492

Browse Source 
git-svn-id: svn+ssh://svn.tuxfamily.org/svnroot/qet/qet/trunk@3493 bfdf4180-ca20-0410-9c96-a3a8aa849046
This commit is contained in:
scorpio810
2014-11-16 20:32:55 +00:00
parent 02df8a5073
commit d544fd3d85
19 changed files with 11 additions and 1744 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
sources/diagram.cpp
View File

@@ -31,7 +31,6 @@
#include "qetgraphicsitem/independenttextitem.h" #include "qetgraphicsitem/independenttextitem.h"
#include "qetapp.h" #include "qetapp.h"
#include "qetgraphicsitem/diagramimageitem.h" #include "qetgraphicsitem/diagramimageitem.h"
#include "qetgraphicsitem/conductor.h"
#include "qetgraphicsitem/qetshapeitem.h" #include "qetgraphicsitem/qetshapeitem.h"
#include "terminal.h" #include "terminal.h"
#include "elementtextsmover.h" #include "elementtextsmover.h"
@@ -79,8 +78,6 @@ Diagram::Diagram(QObject *parent) :
&border_and_titleblock, SIGNAL(diagramTitleChanged(const QString &)), &border_and_titleblock, SIGNAL(diagramTitleChanged(const QString &)),
this, SLOT(titleChanged(const QString &)) this, SLOT(titleChanged(const QString &))
); );
_binaryGrid = new BinaryGrid(this);
} }
/** /**
@@ -108,8 +105,6 @@ Diagram::~Diagram() {
} }
qDeleteAll (deletable_items); qDeleteAll (deletable_items);
delete _binaryGrid;
} }
/** /**
@@ -194,35 +189,6 @@ void Diagram::keyReleaseEvent(QKeyEvent *e) {
bool transmit_event = true; bool transmit_event = true;
if (!isReadOnly()) { if (!isReadOnly()) {
// detecte le relachement d'une touche de direction ( = deplacement d'elements) // detecte le relachement d'une touche de direction ( = deplacement d'elements)
if ( e -> key() == Qt::Key_C) {
Conductor::bDebugGrid= !Conductor::bDebugGrid;
update();
}
else if ( e -> key() == Qt::Key_P) {
Conductor::bAffPoint = !Conductor::bAffPoint;
update();
}
else if ( e -> key() == Qt::Key_S) {
Conductor::bSmooth = !Conductor::bSmooth;
Conductor::reBuild();
update();
}
else if ( e -> key() == Qt::Key_D) {
Conductor::bDebug = !Conductor::bDebug;
Conductor::reBuild();
update();
}
else if ( e -> key() == Qt::Key_Plus) {
Conductor::iIndiceDebug++;
Conductor::reBuild();
update();
}
else if ( e -> key() == Qt::Key_Minus) {
Conductor::iIndiceDebug--;
Conductor::reBuild();
update();
}
if ( if (
(e -> key() == Qt::Key_Left || e -> key() == Qt::Key_Right || (e -> key() == Qt::Key_Left || e -> key() == Qt::Key_Right ||
e -> key() == Qt::Key_Up || e -> key() == Qt::Key_Down) && e -> key() == Qt::Key_Up || e -> key() == Qt::Key_Down) &&

5
sources/diagram.h
View File

@@ -27,7 +27,6 @@
#include "numerotationcontext.h" #include "numerotationcontext.h"
#include "qetproject.h" #include "qetproject.h"
#include "properties/xrefproperties.h" #include "properties/xrefproperties.h"
#include "binarygrid.h"
class Conductor; class Conductor;
class CustomElement; class CustomElement;
@@ -44,7 +43,6 @@ class Terminal;
class ConductorTextItem; class ConductorTextItem;
class DiagramImageItem; class DiagramImageItem;
class ElementTextsMover; class ElementTextsMover;
class BinaryGrid;
/** /**
This class represents an electric diagram. It manages its various child This class represents an electric diagram. It manages its various child
elements, conductors and texts and handles their graphic rendering. elements, conductors and texts and handles their graphic rendering.
@@ -226,9 +224,6 @@ class Diagram : public QGraphicsScene {
void editElementRequired(const ElementsLocation &); void editElementRequired(const ElementsLocation &);
void reportPropertiesChanged(QString); void reportPropertiesChanged(QString);
void XRefPropertiesChanged(); void XRefPropertiesChanged();
public:
BinaryGrid* _binaryGrid;
}; };
Q_DECLARE_METATYPE(Diagram *) Q_DECLARE_METATYPE(Diagram *)

1
sources/diagramview.cpp
View File

@@ -447,7 +447,6 @@ void DiagramView::paste(const QPointF &pos, QClipboard::Mode clipboard_mode) {
// objet pour recuperer le contenu ajoute au schema par le coller // objet pour recuperer le contenu ajoute au schema par le coller
DiagramContent content_pasted; DiagramContent content_pasted;
scene -> fromXml(document_xml, pos, false, &content_pasted); scene -> fromXml(document_xml, pos, false, &content_pasted);
qDebug()<< "PASTE" << texte_presse_papier;
// si quelque chose a effectivement ete ajoute au schema, on cree un objet d'annulation // si quelque chose a effectivement ete ajoute au schema, on cree un objet d'annulation
if (content_pasted.count()) { if (content_pasted.count()) {

1
sources/qetapp.cpp
View File

@@ -59,7 +59,6 @@ RecentFiles *QETApp::projects_recent_files_ = 0;
RecentFiles *QETApp::elements_recent_files_ = 0; RecentFiles *QETApp::elements_recent_files_ = 0;
AboutQET *QETApp::about_dialog_ = 0; AboutQET *QETApp::about_dialog_ = 0;
TitleBlockTemplate *QETApp::default_titleblock_template_ = 0; TitleBlockTemplate *QETApp::default_titleblock_template_ = 0;
bool QETApp::bConductor2 = false;
/** /**
Constructeur Constructeur

1
sources/qetapp.h
View File

@@ -131,7 +131,6 @@ class QETApp : public QETSingleApplication {
static QList<QETTitleBlockTemplateEditor *> titleBlockTemplateEditors(QETProject *); static QList<QETTitleBlockTemplateEditor *> titleBlockTemplateEditors(QETProject *);
static QTextOrientationSpinBoxWidget *createTextOrientationSpinBoxWidget(); static QTextOrientationSpinBoxWidget *createTextOrientationSpinBoxWidget();
static TitleBlockTemplate *defaultTitleBlockTemplate(); static TitleBlockTemplate *defaultTitleBlockTemplate();
static bool bConductor2;
protected: protected:
#ifdef Q_OS_DARWIN #ifdef Q_OS_DARWIN

4
sources/qetarguments.cpp
View File

@@ -16,7 +16,6 @@
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>. along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "qetarguments.h" #include "qetarguments.h"
#include "qetapp.h"
#include "titleblock/templatescollection.h" #include "titleblock/templatescollection.h"
/** /**
@@ -250,9 +249,6 @@ void QETArguments::handleOptionArgument(const QString &option) {
print_license_ = true; print_license_ = true;
options_ << option; options_ << option;
return; return;
} else if (option == QString("--conductor2")) {
QETApp::bConductor2 = true;
return;
} }
#ifdef QET_ALLOW_OVERRIDE_CED_OPTION #ifdef QET_ALLOW_OVERRIDE_CED_OPTION

231
sources/qetgraphicsitem/Mathlib.h
View File

@@ -1,231 +0,0 @@
/***************************************************************************
* Mathlib
*
* Copyright (C) 2003-2004, Alexander Zaprjagaev <frustum@frustum.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
***************************************************************************
* Update 2004/08/19
*
* added ivec2, ivec3 & ivec4 methods
* vec2d, vec3d & vec4d data : added texture coords (s,t,p,q) and color enums (r,g,b,a)
* mat3d & mat4d : added multiple double constructor ad modified methods returning mat3d or mat4d
* optimisations like "x / 2.0f" replaced by faster "x * 0.5f"
* defines of multiples usefull maths values and radian/degree conversions
* vec2d : added methods : set, reset, compare, dot, closestPointOnLine, closestPointOnSegment,
* projectionOnLine, lerp, angle
* vec3d : added methods : set, reset, compare, dot, cross, closestPointOnLine, closestPointOnSegment,
* projectionOnLine, lerp, angle
* vec4d : added methods : set, reset, compare
***************************************************************************
* Update 2014/08/20
*
* Transform float to double
* for using with QT program
* author : Rene Negre <runsys@qelectotech.org>
***************************************************************************
*/
#ifndef __HMATHLIB_D__
#define __HMATHLIB_D__
#include <math.h>
#include <stdlib.h>
#include <QPointF>
#define EPSILON 0.00000001
//#define M_PI 3.141592653589793238462643383279f // PI
#define M_PIDIV2 1.570796326794896619231321691639f // PI / 2
#define M_2PI 6.283185307179586476925286766559f // 2 * PI
#define M_PI2 9.869604401089358618834490999876f // PI au carre
#define M_PIDIV180 0.01745329251994329576923690768488f // PI / 180
#define M_180DIVPI 57.295779513082320876798154814105f // 180 / PI
#define DegToRadd(a) (a)*=M_PIDIV180
#define RadToDegd(a) (a)*=M_180DIVPI
#define DEG2RADd(a) ((a)*M_PIDIV180)
#define RAD2DEGd(a) ((a)*M_180DIVPI)
#define RADIANSd(a) ((a)*M_PIDIV180)
#define DEGRESd(a) ((a)*M_180DIVPI)
#define DegToRad DEG2RADd
const double INV_RAND_MAX = 1.0 / (RAND_MAX);
const double INV_RAND_MAXd = 1.0 / (RAND_MAX );
inline double randomd(double max=1.0) { return max * rand() * INV_RAND_MAX; }
inline double randomd(double min, double max) { return min + (max - min) * INV_RAND_MAX * rand(); }
inline int randomd(int max=RAND_MAX) { return rand()%(max+1); }
class vec2d;
class ivec2;
/*****************************************************************************/
/* */
/* vec2d */
/* */
/*****************************************************************************/
class vec2d {
public:
static int count;
vec2d(void) : x(0), y(0) { count++; }
vec2d(double _x,double _y) : x(_x), y(_y) { count++; }
vec2d(const double *_v) : x(_v[0]), y(_v[1]) { count++; }
vec2d(const vec2d &_p1, const vec2d & _p2) : x(_p2.x-_p1.x), y(_p2.y-_p1.y) { count++; }
vec2d(const QPointF &_qp) : x(_qp.x()), y(_qp.y()) { count++; }
~vec2d() { count--; }
bool operator==(const vec2d &_v) { return (fabs(this->x - _v.x) < EPSILON && fabs(this->y - _v.y) < EPSILON); }
int operator!=(const vec2d &_v) { return !(*this == _v); }
vec2d &operator=(double _f) { this->x=_f; this->y=_f; return (*this); }
const vec2d operator*(double _f) const { return vec2d(this->x * _f,this->y * _f); }
const vec2d operator/(double _f) const {
if(fabs(_f) < EPSILON) return *this;
_f = 1.0f / _f;
return (*this) * _f;
}
const vec2d operator+(const vec2d &_v) const { return vec2d(this->x + _v.x,this->y + _v.y); }
const vec2d operator-() const { return vec2d(-this->x,-this->y); }
const vec2d operator-(const vec2d &_v) const { return vec2d(this->x - _v.x,this->y - _v.y); }
vec2d &operator*=(double _f) { return *this = *this * _f; }
vec2d &operator/=(double _f) { return *this = *this / _f; }
vec2d &operator+=(const vec2d &_v) { return *this = *this + _v; }
vec2d &operator-=(const vec2d &_v) { return *this = *this - _v; }
double operator*(const vec2d &_v) const { return this->x * _v.x + this->y * _v.y; }
operator double*() { return this->v; }
operator const double*() const { return this->v; }
// double &operator[](int _i) { return this->v[_i]; }
// const double &operator[](int _i) const { return this->v[_i]; }
void set(double _x,double _y) { this->x = _x; this->y = _y; }
void reset(void) { this->x = this->y = 0; }
double length(void) const { return sqrtf(this->x * this->x + this->y * this->y); }
double normalize(void) {
double inv,l = this->length();
if(l < EPSILON) return 0.0f;
inv = 1.0f / l;
this->x *= inv;
this->y *= inv;
return l;
}
double dot(const vec2d &v) { return ((this->x*v.x) + (this->y*v.y)); } // Produit scalaire
bool compare(const vec2d &_v,double epsi=EPSILON) { return (fabs(this->x - _v.x) < epsi && fabs(this->y - _v.y) < epsi); }
// retourne les coordonnée du point le plus proche de *this sur la droite passant par vA et vB
vec2d closestPointOnLine(const vec2d &vA, const vec2d &vB) { return (((vB-vA) * this->projectionOnLine(vA, vB)) + vA); }
// retourne les coordonnée du point le plus proche de *this sur le segment vA,vB
vec2d closestPointOnSegment(const vec2d &vA, const vec2d &vB) {
double factor = this->projectionOnLine(vA, vB);
if (factor <= 0.0f) return vA;
if (factor >= 1.0f) return vB;
return (((vB-vA) * factor) + vA);
}
// retourne le facteur de la projection de *this sur la droite passant par vA et vB
double projectionOnLine(const vec2d &vA, const vec2d &vB) {
vec2d v(vB - vA);
return v.dot(*this - vA) / v.dot(v);
}
// Fonction d'interpolation linéaire entre 2 vecteurs
vec2d lerp(vec2d &u, vec2d &v, double factor) { return ((u * (1 - factor)) + (v * factor)); }
vec2d lerp(vec2d &u, vec2d &v, vec2d& factor) { return (vec2d((u.x * (1 - factor.x)) + (v.x * factor.x), (u.y * (1 - factor.y)) + (v.y * factor.y))); }
double angle(void) { return (double)atan2(this->y,this->x); }
double angle(const vec2d &v) { return (double)atan2(v.y-this->y,v.x-this->x); }
vec2d mul(const vec2d &v) { return vec2d(this->x*=v.x, this->y*=v.y); } // Produit des ccordonnes
vec2d& mulCoord(const vec2d &v) { this->x*=v.x, this->y*=v.y; return *this; } // Produit des ccordonnes
double addCoord() { return this->x + this->y; } // Produit des ccordonnes
vec2d vabs(void) { return vec2d( fabs(this->x), fabs(this->y) ); }
void abs(void) { this->x = fabs(this->x); this->y = fabs(this->y); }
vec2d exch(void) { return vec2d( this->y, this->x ); }
QPointF toQPointF() { return QPointF(this->x, this->y); }
vec2d vnormalize(void) {
double inv,l = this->length();
if(l < EPSILON) return vec2d(0.0,0.0);
inv = 1.0f / l;
return vec2d(this->x * inv, this->y * inv);
}
union {
struct {double x,y;};
struct {double s,t;};
double v[2];
};
};
inline vec2d operator*(double fl, const vec2d& v) { return vec2d(v.x*fl, v.y*fl);}
inline double Dot(const vec2d& a, const vec2d& b) { return(a.x*b.x+a.y*b.y); }
/*****************************************************************************/
/* */
/* ivec2 */
/* */
/*****************************************************************************/
class ivec2 {
public:
ivec2(void) : a(0), b(0) { }
ivec2(long _a,long _b) : a(_a), b(_b) { }
ivec2(const long *iv) : a(iv[0]), b(iv[1]) { }
ivec2(const ivec2 &iv) : a(iv.a), b(iv.b) { }
ivec2(const vec2d &v) : x((int)v.x), y((int)v.y) { }
int operator==(const ivec2 &iv) { return ((this->a == iv.a) && (this->b == iv.b)); }
int operator!=(const ivec2 &iv) { return !(*this == iv); }
ivec2 &operator=(long _i) { this->x=_i; this->y=_i; return (*this); }
const ivec2 operator*(long _i) const { return ivec2(this->a * _i,this->b * _i); }
const ivec2 operator/(long _i) const { return ivec2(this->a / _i,this->b / _i); }
const ivec2 operator+(const ivec2 &iv) const { return ivec2(this->a + iv.a,this->b + iv.b); }
const ivec2 operator-() const { return ivec2(-this->a,-this->b); }
const ivec2 operator-(const ivec2 &iv) const { return ivec2(this->a - iv.a,this->b - iv.b); }
ivec2 &operator*=(long _i) { return *this = *this * _i; }
ivec2 &operator/=(long _i) { return *this = *this / _i; }
ivec2 &operator+=(const ivec2 &iv) { return *this = *this + iv; }
ivec2 &operator-=(const ivec2 &iv) { return *this = *this - iv; }
long operator*(const ivec2 &iv) const { return this->a * iv.a + this->b * iv.b; }
operator long*() { return this->i; }
operator const long*() const { return this->i; }
// long &operator[](int _i) { return this->i[_i]; }
// const long &operator[](int _i) const { return this->i[_i]; }
void set(long _a,long _b) { this->a = _a; this->b = _b; }
void reset(void) { this->a = this->b = 0; }
void swap(ivec2 &iv) { long tmp=a; a=iv.a; iv.a=tmp; tmp=b; b=iv.b; iv.b=tmp; }
void swap(ivec2 *iv) { this->swap(*iv); }
union {
struct {long a,b;};
struct {long x,y;};
long i[2];
};
};
#endif // __HMATHLIB_D__

409
sources/qetgraphicsitem/binarygrid.cpp
View File

@@ -1,409 +0,0 @@
/*
* binarygrid.cpp
*
* Created on: 8 nov. 2014
* Author: rene
*/
#include <QtDebug>
#include "element.h"
#include "binarygrid.h"
/*
*
*/
BinaryGrid::BinaryGrid( Diagram* d ) {
diagram = d;
reset();
}
/*
*
*/
BinaryGrid::~BinaryGrid() {
}
/*
*
*/
QString reverse( QString s ) {
QString ret = "";
const int nb = s.count();
for(int i=0; i<nb; i++) {
ret.append(s.at(nb-i-1));
}
return ret;
}
/*
*
*/
void printVec2d( QString str, vec2d v ) {
qDebug() << str <<" ("<< v.x <<","<< v.y <<")";
}
/*
*
*/
void printDoubl( QString str, double d ) {
qDebug() << str <<" "<< d;
}
/*
*
*/
QString getStringLine( U64 * line ) {
QString ret = "";
for ( int i=0; i<1; i++ ) {
U64 mask = 1;
for( int j=0; j<64; j++ ) {
if ( (line[i] & mask) == 0 ) ret += ".";
else ret += "1";
mask <<= 1;
}
}
return ret;
}
void rect2side( vec2d* topLeft, vec2d* bottomRight, QRectF qRectF ) {
*topLeft = vec2d( qRectF.topLeft() );
*bottomRight = vec2d( qRectF.bottomRight() );
}
/*
*
*/
void BinaryGrid::reset() {
for( int i=0; i<400; i++ ) {
for( int j=0; j<5; j++ ) {
bitHrzt [i][j] = 0ULL;
bitVrtc [i][j] = 0ULL;
}
}
}
/*
*
*/
void BinaryGrid::build( Conductor* pExceptConductor) {
if ( diagram ){
QList<Element *> elements = diagram -> elements();
for ( int i=0; i<elements.size(); i++ ) {
Element* element = elements[i];
if ( element -> terminals().size() == 0 ) continue;
vec2d topLeft, bottomRight;
rect2side( &topLeft, &bottomRight, element -> boundingRectTrue() );
add2grid( topLeft, bottomRight, 3 );
QList<Conductor*> conductors = element->conductors();
const int nb = conductors.size();
for( int i=0; i<nb; i++ ) {
if ( conductors[i] == pExceptConductor ) continue;
add2grid( conductors[i] );
}
}
}
}
/*
*
*/
void BinaryGrid::reBuild(Conductor* pExceptConductor) {
reset();
build(pExceptConductor);
}
/*
* bit 0 for x = 0
* bit 1 for x = 10
* bit 2 for x = 20
* ....
*
* Compute mask until haven't point (one more)
* for example x = 100
* mask = 0001 1111 1111
*/
void BinaryGrid::computeFirstMask( double d, U64* mask ) {
int n = (int)(d) /640;
d = fmod(d, 640);
U64 uMask = (U64)(d - 1.0) / 10;
mask[n] = 1ULL << ++uMask;
(U64)(mask[n]--);
// Because at umask = 64 the result is mask[n]=256 why ???? 64bits => 8 bits ???
if ( uMask == 64 ) mask[n] = (U64)-1;
for( int i=0; i<n; i++) mask[i] = (U64)-1;
for( int i=n+1; i<5; i++) mask[i] = (U64)0;
}
/*
*
* Compute mask until haven't point
* for example x = 90
* mask = 0001 1111 1111
*
* result :
* for a horizontal line from 50 to 110
* first mask = 0000 0000 1111 (compute from 50)
* second mask = 0111 1111 1111 (compute from 110)
*
* xor result = 0111 1111 0000
*
*/
void BinaryGrid::computeSecondMask( double d, U64* mask ) {
int n = (int)d /640;
d = fmod(d, 640);
U64 uMask = (U64)(d) / 10;
mask[n] = 1ULL << ++uMask;
(U64)(mask[n]--);
// Because at umask = 64 the result is mask[n]=256 why ???? 64bits => 8 bits ???
if ( uMask == 64 ) mask[n] = (U64)-1;
for( int i=0; i<n; i++) mask[i] = (U64)-1;
for( int i=n+1; i<5; i++) mask[i] = (U64)0;
}
/*
*
*/
int BinaryGrid::computeFirstLine( double d) {
return (int) (((d-1)/10)+1);
}
/*
*
*/
int BinaryGrid::computeLastLine( double d) {
return (int) d/10;
}
/*
*
*/
void BinaryGrid::debugGrid(int deb, int fin) {
for ( int i=deb; i<=fin; i++ ) {
// char * binary0 = getStringLine( bitHrzt[i] ).toStdString();
// qDebug( "line : %02d %s %s", i, getStringLine( bitHrzt[i] ).toStdString(), getStringLine( bitVrtc[i] ).toStdString() );
qDebug() <<"line "<< (i+10) <<" "<< getStringLine( bitHrzt[i] ) <<" "<< getStringLine( bitVrtc[i] );
}
}
/*
*
*/
void BinaryGrid::debugGrid() {
debugGrid(2,45);
}
/*
*
*/
void BinaryGrid::add2grid( vec2d topLeft, vec2d bottomRight, int map ) {
double left = vec2d(topLeft).mul(vec2d(1.0,0.0)).addCoord();
double right = vec2d(bottomRight).mul(vec2d(1.0,0.0)).addCoord();
double top = vec2d(topLeft).mul(vec2d(0.0,1.0)).addCoord();
double bottom = vec2d(bottomRight).mul(vec2d(0.0,1.0)).addCoord();
// mask 0 and mask 1
U64 M0[5];
computeFirstMask( left, M0 );
U64 M1[5];
computeSecondMask( right, M1 );
// mask = mask0 xor mask1
U64 mask[5];
for( int i=0; i<5; i++ ) mask[i] = M0[i] ^ M1[i];
int idx0 = computeFirstLine(top);
int idx1 = computeLastLine(bottom);
for ( int i= idx0; i<idx1+1; i++ ) {
for ( int j=0; j<5; j++ ) {
if ( map & HORI ) bitHrzt[i][j] |= mask[j];
if ( map & VERT ) bitVrtc[i][j] |= mask[j];
}
}
}
/*
*
*/
void BinaryGrid::orderVect( vec2d& v1, vec2d& v2 ) {
if ( v1.x > v2.x || v1.y > v2.y ) {
vec2d v = vec2d( v1 );
v1 = v2;
v2 = v;
}
}
/*
*
*/
void BinaryGrid::add2grid( Conductor* pConductor ) {
QList <vec2d> vec2ds = pConductor -> getVec2ds();
const int nb = vec2ds.size() - 1;
for( int i=0; i<nb; i++ ) {
vec2d v1 = vec2d( vec2ds[i] + vec2d(pConductor->scenePos()) );
vec2d v2 = vec2d( vec2ds[i+1] + vec2d(pConductor->scenePos()) );
orderVect( v1, v2 );
vec2d vDir = vec2d( v1, v2 );
if ( vDir.dot( vec2d(0.0,1.0) ) == 0 ) add2grid( v1, v2, VERT);
else add2grid( v1, v2, HORI );
}
}
/*
*
*/
bool BinaryGrid::testMask( U64* mask, int lineBeg, int lineEnd, int map ) {
for ( int i=lineBeg; i<=lineEnd; i++ ) {
for( int j=0; j<5; j++ ) {
U64 val = 0;
if ( (map & HORI) == HORI ) val = bitHrzt[i][j];
if ( (map & VERT) == VERT ) val = bitVrtc[i][j];
if ( (val|mask[j]) != (val^mask[j]) ) return true;
}
}
return false;
}
/*
*
*/
bool BinaryGrid::test( vec2d p1, vec2d p2 ) {
qDebug() <<"BinaryGrid::test";
orderVect( p1, p2 );
// printVec2d( "p1 : ", p1 );
// printVec2d( "p2 : ", p2 );
double left = vec2d(p1).mul(vec2d(1.0,0.0)).addCoord();
double right = vec2d(p2).mul(vec2d(1.0,0.0)).addCoord();
double top = vec2d(p1).mul(vec2d(0.0,1.0)).addCoord();
double bottom = vec2d(p2).mul(vec2d(0.0,1.0)).addCoord();
int map;
vec2d vDir = vec2d( p1, p2 );
if ( vDir.dot( vec2d(0.0,1.0) ) == 0 ) map = HORI;
else map = VERT;
// compute mask 0 and mask 1
U64 M0[5]; computeFirstMask( left, M0 );
U64 M1[5]; computeSecondMask( right, M1 );
// mask = mask0 xor mask1
U64 mask[5];
for( int i=0; i<5; i++ ) mask[i] = M0[i] ^ M1[i];
int idx0 = computeFirstLine(top);
int idx1 = computeLastLine(bottom);
// qDebug() << "idx 0 : "<< idx0;
// qDebug() << "idx 1 : "<< idx1;
//
// debugGrid( idx0-2, idx1+2);
return testMask( mask, idx0, idx1, map );
}
/*
*
*/
bool BinaryGrid::computeMinSegment( vec2d p1, vec2d p2 ) {
qDebug() <<"BinaryGrid::test";
orderVect( p1, p2 );
// printVec2d( "p1 : ", p1 );
// printVec2d( "p2 : ", p2 );
double left = vec2d(p1).mul(vec2d(1.0,0.0)).addCoord();
double right = vec2d(p2).mul(vec2d(1.0,0.0)).addCoord();
double top = vec2d(p1).mul(vec2d(0.0,1.0)).addCoord();
double bottom = vec2d(p2).mul(vec2d(0.0,1.0)).addCoord();
int map;
vec2d vDir = vec2d( p1, p2 );
if ( vDir.dot( vec2d(0.0,1.0) ) == 0 ) map = HORI;
else map = VERT;
// compute mask 0 and mask 1
U64 M0[5]; computeFirstMask( left, M0 );
U64 M1[5]; computeSecondMask( right, M1 );
// mask = mask0 xor mask1
U64 mask[5];
for( int i=0; i<5; i++ ) mask[i] = M0[i] ^ M1[i];
int idx0 = computeFirstLine(top);
int idx1 = computeLastLine(bottom);
// qDebug() << "idx 0 : "<< idx0;
// qDebug() << "idx 1 : "<< idx1;
//
// debugGrid( idx0-2, idx1+2);
return testMask( mask, idx0, idx1, map );
}

52
sources/qetgraphicsitem/binarygrid.h
View File

@@ -1,52 +0,0 @@
/*
* binarygrid.h
*
* Created on: 8 nov. 2014
* Author: rene
*/
#ifndef BINARYGRID_H_
#define BINARYGRID_H_
#include "diagram.h"
#include "conductor.h"
#include "Mathlib.h"
typedef unsigned long long U64;
#define HORI 0x01
#define VERT 0x02
class BinaryGrid {
public:
BinaryGrid(Diagram * diagram);
~BinaryGrid();
void reset();
void build(Conductor*);
void reBuild(Conductor*);
void computeFirstMask( double, U64* );
void computeSecondMask( double, U64*);
int computeFirstLine( double );
int computeLastLine( double );
void debugGrid(int, int);
void debugGrid();
void add2grid( vec2d, vec2d, int );
void orderVect( vec2d&, vec2d& );
void add2grid( Conductor* );
bool testMask( U64*, int, int, int );
bool test( vec2d, vec2d );
bool computeMinSegment( vec2d, vec2d );
private:
U64 bitHrzt[400][5];
U64 bitVrtc[400][5];
Diagram* diagram;
};
#endif /* BINARYGRID_H_ */

870
sources/qetgraphicsitem/conductor.cpp
View File

@@ -27,31 +27,12 @@
#include "terminal.h" #include "terminal.h"
#include "conductorautonumerotation.h" #include "conductorautonumerotation.h"
#include "conductorpropertiesdialog.h" #include "conductorpropertiesdialog.h"
#include "../qetapp.h" #define PR(x) qDebug() << #x " = " << x;
#include "binarygrid.h"
#define PR(x) qDebug() << #x " = " << x;extend
bool Conductor::pen_and_brush_initialized = false; bool Conductor::pen_and_brush_initialized = false;
QPen Conductor::conductor_pen = QPen(); QPen Conductor::conductor_pen = QPen();
QBrush Conductor::conductor_brush = QBrush(); QBrush Conductor::conductor_brush = QBrush();
QBrush Conductor::square_brush = QBrush(Qt::darkGreen); QBrush Conductor::square_brush = QBrush(Qt::darkGreen);
int vec2d::count = 0;
bool Conductor::bAffPoint = true;
bool Conductor::bSmooth = false;
Conductor* Conductor::lastConductor = NULL;
QPointF Conductor::P1;
Qet::Orientation Conductor::O1;
QPointF Conductor::P2;
Qet::Orientation Conductor::O2;
bool Conductor::bDebug = false;
bool Conductor::bDebugGrid = false;
int Conductor::iIndiceDebug = 0;
/** /**
Constructeur Constructeur
@param p1 Premiere Borne a laquelle le conducteur est lie @param p1 Premiere Borne a laquelle le conducteur est lie
@@ -118,7 +99,6 @@ Conductor::Conductor(Terminal *p1, Terminal* p2, Diagram *parent_diagram) :
this, this,
SLOT(displayedTextChanged()) SLOT(displayedTextChanged())
); );
bMouseOver = false;
} }
/** /**
@@ -191,11 +171,6 @@ void Conductor::updateConductorPath(const QPointF &p1, Qet::Orientation o1, cons
Q_UNUSED(o1); Q_UNUSED(o1);
Q_UNUSED(o2); Q_UNUSED(o2);
if ( QETApp::bConductor2 ) {
//qDebug() << "updateConductorPath2";
generateConductorPath2(p1, o1, p2, o2 );
return;
}
ConductorProfile &conductor_profile = conductor_profiles[currentPathType()]; ConductorProfile &conductor_profile = conductor_profiles[currentPathType()];
Q_ASSERT_X(conductor_profile.segmentsCount(QET::Both) > 1, "Conductor::priv_modifieConductor", "pas de points a modifier"); Q_ASSERT_X(conductor_profile.segmentsCount(QET::Both) > 1, "Conductor::priv_modifieConductor", "pas de points a modifier");
@@ -321,11 +296,6 @@ QHash<ConductorSegmentProfile *, qreal> Conductor::shareOffsetBetweenSegments(
@param o2 Orientation de la borne 2 @param o2 Orientation de la borne 2
*/ */
void Conductor::generateConductorPath(const QPointF &p1, Qet::Orientation o1, const QPointF &p2, Qet::Orientation o2) { void Conductor::generateConductorPath(const QPointF &p1, Qet::Orientation o1, const QPointF &p2, Qet::Orientation o2) {
if ( QETApp::bConductor2 ){
//qDebug() << "generateConductorPath2";
generateConductorPath2(p1, o1, p2, o2 );
return;
}
QPointF sp1, sp2, depart, newp1, newp2, arrivee, depart0, arrivee0; QPointF sp1, sp2, depart, newp1, newp2, arrivee, depart0, arrivee0;
Qet::Orientation ori_depart, ori_arrivee; Qet::Orientation ori_depart, ori_arrivee;
@@ -421,477 +391,6 @@ void Conductor::generateConductorPath(const QPointF &p1, Qet::Orientation o1, co
segmentsToPath(); segmentsToPath();
} }
void Conductor::addPoint( vec2d p ) {
vec2d vScenePos = vec2d(scenePos());
p -= vScenePos;
qDebug() << "Test Point : "<< currentIndice;
if ( currentIndice > 1 ){
vec2d ori = vec2d( vec2ds[currentIndice-1] );
if ( diagram() ) {
if ( diagram() -> _binaryGrid ->test( ori, p ) )
qDebug()<< "Test droie OK de "<< currentIndice-1 <<" à "<< currentIndice;
else
qDebug()<< "Test droie NOK de "<< currentIndice-1 <<" à "<< currentIndice;
}
}
if ( bDebug ) {
qDebug() << "--------------------------";
qDebug() << " point no : " << currentIndice;
printVec2d( " Ajout de : ", p );
qDebug() << "--------------------------";
}
vec2ds << p;
currentIndice++;
if ( currentIndice == iIndiceDebug ) bDebug = true;
else bDebug = false;
}
void Conductor::printVec2d( QString str, vec2d v ) {
qDebug() << str <<" ("<< v.x <<","<< v.y <<")";
}
void Conductor::printDoubl( QString str, double d ) {
qDebug() << str <<" "<< d;
}
/*
*
*/
vec2d Conductor::orientation2vec2d( Qet::Orientation orientation ) {
switch(orientation) {
case Qet::North: return vec2d( 0.0,-1.0 );
case Qet::East: return vec2d( 1.0, 0.0 );
case Qet::South: return vec2d( 0.0, 1.0 );
case Qet::West: return vec2d(-1.0, 0.0 );
}
return vec2d(0.0,0.0);
}
void Conductor::rect2corner( vec2d* topLeft, vec2d* topRight, vec2d*bottomLeft, vec2d* bottomRight, QRectF qRectF, QPointF pos ) {
*topLeft = vec2d( pos + qRectF.topLeft() ) + vec2d(1.0,1.0);
*topRight = vec2d( pos + qRectF.topRight() ) + vec2d(-1.0,1.0);
*bottomLeft = vec2d( pos + qRectF.bottomLeft() ) + vec2d(1.0,-1.0);
*bottomRight = vec2d( pos + qRectF.bottomRight() ) + vec2d(-1.0,-1.0);
}
void Conductor::rect2side( vec2d* topLeft, vec2d* bottomRight, QRectF qRectF, QPointF pos ) {
*topLeft = vec2d( pos + qRectF.topLeft() );
*bottomRight = vec2d( pos + qRectF.bottomRight() );
}
void Conductor::rect2side( vec2d* topLeft, vec2d* bottomRight, QRectF qRectF ) {
*topLeft = vec2d( qRectF.topLeft() );
*bottomRight = vec2d( qRectF.bottomRight() );
}
int Conductor::sign( double d ) { return d==0.0 ? 0 : d<-EPSILON ? -1: 1;}
int Conductor::computeSign( vec2d p1, vec2d p2, vec2d vDir ) {
vec2d c_p1 = vec2d( p1 ).mulCoord( vDir );
vec2d c_p2 = vec2d( p2 ).mulCoord( vDir );
// qDebug() << " computeSign()";
// printVec2d( " p1 : ", c_p1 );
// printVec2d( " p2 : ", c_p2 );
int ret = sign( vec2d( c_p1, c_p2 ).addCoord() );
// printDoubl( " Sign : ", ret );
return ret;
}
bool Conductor::isInsideRect( vec2d pt, vec2d topLeft, vec2d bottomRight ) {
int s_ol = computeSign( pt, topLeft , east );
int s_or = computeSign( pt, bottomRight , east );
if ( s_ol == s_or ) return false;
s_ol = computeSign( pt, topLeft , south );
s_or = computeSign( pt, bottomRight , south );
if ( s_ol == s_or ) return false;
return true;
}
bool Conductor::isInsideRect( vec2d orig, vec2d dest, vec2d topLeft, vec2d bottomRight ) {
int s_ol = computeSign( orig, topLeft , east );
int s_or = computeSign( orig, bottomRight , east );
int s_dl = computeSign( dest, topLeft , east );
int s_dr = computeSign( dest, bottomRight , east );
if ( s_ol == s_or && s_ol == s_dl && s_ol == s_dr ) {
return false;
}
s_ol = computeSign( orig, topLeft , south );
s_or = computeSign( orig, bottomRight , south );
s_dl = computeSign( dest, topLeft , south );
s_dr = computeSign( dest, bottomRight , south );
if ( s_ol == s_or && s_ol == s_dl && s_ol == s_dr ) {
return false;
}
return true;
}
void Conductor::computeIntersection( vec2d orig, vec2d& dest, vec2d topLeft, vec2d bottomRight ) {
vec2d orientation;
vec2d vDir = vec2d( orig, dest ).vnormalize();
double sign = vDir.addCoord();
if ( vDir.dot(south) == 0.0 ) orientation = east;
else orientation = south;
if ( bDebug ) {
printVec2d( " orig : ", orig );
printVec2d( " dest : ", orig );
printVec2d( " dir : ", orientation);
}
vec2d vOL = vec2d( orig, topLeft ).mul(orientation);
vec2d vOR = vec2d( orig, bottomRight).mul(orientation);
double dOL = vOL.addCoord() * sign;
double dOR = vOR.addCoord() * sign;
if ( bDebug ) {
printDoubl( " dOL : ", dOL );
printDoubl( " dOR : ", dOR );
}
double res;
if ( dOL < dOR ) {
res = dOL;
res -= 10.0;
}
else {
res = dOR;
res += 10.0;
}
dest = orig + res * vDir;
snapOnGrid(dest);
if ( bDebug ) {
printVec2d( " dest : ", dest);
}
}
bool Conductor::isInsideElement( vec2d pt, Element* element) {
vec2d topLeft, bottomRight;
rect2side( &topLeft, &bottomRight, element -> boundingRectTrue() );
return isInsideRect( pt, topLeft, bottomRight );
}
Element* Conductor::intersectionElement( vec2d &pt, vec2d ori, Element* element ) {
if ( element == NULL ) return NULL;
vec2d topLeft, bottomRight;
rect2side( &topLeft, &bottomRight, element -> boundingRectTrue() );
if ( bDebug ) {
qDebug() << " test intersection avec : "<< element -> name();
printVec2d( " topLeft : ", topLeft );
printVec2d( " bottomRgiht : ", bottomRight );
}
if ( isInsideRect( ori, pt, topLeft, bottomRight ) ) {
if ( bDebug ) {
qDebug() <<" *** Intersection ";
qDebug() <<" *** computeInstersection";
}
computeIntersection( ori, pt, topLeft, bottomRight );
return element;
}
else {
if ( bDebug ) {
qDebug() <<" Pas d'intersection ";
//intersection( pt, ori, topLeft, bottomRight );
}
}
return NULL;
}
Element* Conductor::intersectionElements( vec2d &pt, vec2d ori ) {
Element* returnElement = NULL;
if ( bDebug ) {
qDebug() << "Intersection Elements";
}
if ( diagram() ){
QList<Element *> elements = diagram() -> elements();
for ( int i=0; i<elements.size(); i++ ) {
Element* element = elements[i];
//if ( element -> terminals() != null ) continue;
if ( element -> terminals().size() == 0 ) continue;
Element* ret = intersectionElement( pt, ori, element );
if ( ret ) returnElement = ret;
}
}
return returnElement;
}
void Conductor::intersectionConductors( vec2d &pt, vec2d ori ) {
if ( bDebug ) {
qDebug() << "Intersection Conductor";
}
if ( diagram() ){
QList<Element *> elements = diagram() -> elements();
int nbElem = elements.size();
for ( int i=0; i<nbElem; i++ ) {
Element* element = elements[i];
QList<Terminal *> terminals = element -> terminals();
int nbTerm = terminals.size();
for( int j=0; j<nbTerm; j++ ) {
Terminal * terminal = terminals[j];
QList<Conductor *> conductors = terminal -> conductors();
int nbCond = conductors.size();
for( int k=0; k<nbCond; k++ ) {
Conductor* conductor = conductors[k];
QList<vec2d> vec2ds = conductor -> vec2ds;
int nbVec2d= vec2ds.size() - 1 ;
vec2d vDir = vec2d(ori, pt).vnormalize();
//return;
for( int l=0; l<nbVec2d; l++ ) {
vec2d topLeft = vec2ds[l];
vec2d bottomRight = vec2ds[l+1];
vec2d vDirConductor = vec2d(topLeft, bottomRight).vnormalize();
if ( vDirConductor.dot(east) < 0.0 || vDirConductor.dot(south) <0.0 ) {
bottomRight = vec2ds[l];
topLeft = vec2ds[l+1];
}
topLeft -= vec2d( 2.0, 2.0 );
bottomRight += vec2d( 2.0, 2.0 );
/*
vec2d oldPt = vec2d(pt);
while( ori != pt ) {
isInsideRect(ori, pt, topLeft, bottomRight);
//pt = ori + 10.0 * vDir;
pt -= 10.0 * vDir;
qDebug() <<" pt dans conducteur Changement... idx : "<< currentIndice << " "<< pt.addCoord();
}
*/
}
}
}
}
}
bDebug = false;
}
void Conductor::evaluatePath( vec2d ori, vec2d& pt, Element * element, double test ) {
if ( element == NULL ) return;
vec2d vDir = vec2d(ori, pt).vnormalize();
vec2d vOrtho = vec2d(vDir).exch();
if ( vDir == vec2d(0.0,0.0) ) return;
if ( bDebug ) {
qDebug() << "EvaluatePath : "<< test <<" sign "<< sign(vDir.addCoord());
}
if ( fabs(test) > 400.0 ) return;
vOrtho = vOrtho.vabs();
vec2d o = pt + test * vOrtho;
vec2d p = o + 50.0 * vDir;
if ( bDebug ) {
printDoubl( " evaluate t : ", test );
printVec2d( " evaluate p : ", p );
printVec2d( " evaluate o : ", o );
}
intersectionElement( p, o, element );
if ( bDebug ) {
printVec2d( " evaluate p : ", p );
printVec2d( " evaluate o : ", o );
}
test += sign(test) * 10.0;
if ( p == o )
evaluatePath( ori, pt, element, test );
else
pt = o;
}
double Conductor::computeSensEvaluatePath( vec2d ori, vec2d pt, vec2d dest ) {
vec2d vDir = vec2d( ori, dest );
vec2d vNew = vec2d( ori, pt ).exch().vabs();
vDir = vDir.mul(vNew);
double ret = vDir.addCoord();
ret = ret >= 0.0 ? 1.0 : -1.0;
return ret;
}
vec2d Conductor::previousDir() {
if ( currentIndice > 2 ) {
vec2d p2 = vec2ds[currentIndice - 1];
vec2d p1 = vec2ds[currentIndice - 2];
vec2d vDir = vec2d( p1, p2 ).vnormalize();
return vDir;
}
return vec2d(0.0,0.0);
}
vec2d Conductor::findNextPoint( vec2d p1, vec2d& vD1, vec2d p2, vec2d vD2 ) {
vec2d vP1P2n = vec2d(p1, p2).vnormalize();
double dot = vD1.dot(vD2);
double coef = 1.0;
vec2d v = vec2d( p1, p2 );
vec2d vnorm = v.vnormalize();
// if direction are opposite the next point is in the middle
// and not in the same line
if ( dot < -0.9 && vnorm.dot(vD1) != 1.0) { coef = 0.5; }
// tout droit
if ( vP1P2n == vD1 ) {
/*
vec2d newPoint = vec2d( p2 );
Element* element = intersectionElements( newPoint, p1 );
if ( element == NULL ) {
addPoint( p2 );
return p2;
}
*/
coef = 1.0;
}
// New point follow first direction horizontal or vertical
v.x *= coef * fabs(vD1.x);
v.y *= coef * fabs(vD1.y);
vec2d newPoint = p1 + v;
// snap on grid
snapOnGrid( newPoint );
vec2d svgPt = newPoint;
//intersectionConductors( newPoint, p1 );
Element* element = intersectionElements( newPoint, p1 );
if ( newPoint != svgPt ) {
//vec2d newDir;
vec2d svgEvalPt = newPoint;
// compute sens
double first = computeSensEvaluatePath( p1, newPoint, p2) * 10.0;
evaluatePath( p1, newPoint, element, first );
if ( svgEvalPt != newPoint ) {
addPoint( svgEvalPt );
// on conserve la direction
return newPoint;
}
}
else {
if ( vP1P2n == vD1 && newPoint == p2 )
return p2;
}
// compute new direction
vec2d newD1 = vec2d( newPoint, p2 );
newD1.mul(vD1.exch().vabs());
newD1.normalize();
if ( newD1 == vec2d(0.0,0.0) ) {
newD1 = vD1.exch();
addPoint( newPoint );
newPoint += 60.0 * newD1;
newD1 = vD1;
}
// normalize vector 1 unit lenght
newD1.normalize();
//Change vD1 (it's a reference) isn't it
vD1.x = newD1.x;
vD1.y = newD1.y;
// printVec2d(" New dir : ", vD1);
// printVec2d("New point : ", newPoint);
// printVec2d("New point : ", newPoint);
return newPoint;
}
/** /**
Prolonge une borne. Prolonge une borne.
@param terminal Le point correspondant a la borne @param terminal Le point correspondant a la borne
@@ -914,336 +413,10 @@ QPointF Conductor::extendTerminal(const QPointF &terminal, Qet::Orientation term
case Qet::West: case Qet::West:
extended_terminal = QPointF(terminal.x() - ext_size, terminal.y()); extended_terminal = QPointF(terminal.x() - ext_size, terminal.y());
break; break;
default: extended_terminal = terminal; break; default: extended_terminal = terminal;
} }
return(extended_terminal); return(extended_terminal);
} }
vec2d Conductor::extendOutOfElement( vec2d pt, vec2d vDir, Element* element) {
vec2d newPt = pt;
if ( element ) {
while( isInsideElement( newPt , element )) {
newPt += 10.0 * vDir;
}
}
return newPt;
}
void Conductor::snapOnGrid( vec2d& pt ) {
vec2d newPt;
//pt += vec2d(5.0,5.0);
int x = (int) pt.x % 10;
int X = (int) pt.x / 10;
if ( x >= 5 ) X++;
newPt.x = 10.0 * X;
int y = (int) pt.y % 10;
int Y = (int) pt.y / 10;
if ( y >= 5 ) Y++;
newPt.y = 10.0 * Y;
pt = newPt;
}
/*
*
*/
void Conductor::generateConductorPath2( const QPointF &p1, Qet::Orientation o1, const QPointF &p2, Qet::Orientation o2) {
//diagram() -> _binaryGrid -> add2grid( vec2d(25.0,10.0), vec2d(405.0,45.0) );
if ( diagram() )
if ( diagram()->_binaryGrid)
diagram() -> _binaryGrid -> reBuild(this);
QPointF sp1, sp2, depart;
vec2d newp1, newp2;
vec2d vScenePos = vec2d(scenePos());
Conductor::lastConductor = this;
Conductor::P1 = p1;
Conductor::O1 = o1;
Conductor::P2 = p2;
Conductor::O2 = o2;
//Qet::Orientation ori_depart, ori_arrivee;
qDebug() << "-------------------------------";
if ( diagram() ){
qDebug() <<"Diagram title : "<< diagram() -> title();
}
// s'assure qu'il n'y a ni points
QList<QPointF> points;
vec2ds.clear();
// mappe les points par rapport a la scene
if ( p1.x() < p2.x() ) {
sp1 = mapFromScene(p1);
sp2 = mapFromScene(p2);
}
else {
sp1 = mapFromScene(p2);
sp2 = mapFromScene(p1);
Qet::Orientation o = o1;
o1 = o2;
o2 = o;
}
// prolonge les bornes
Element* element;
Element* element1 = terminal1 -> parentElement();
Element* element2 = terminal2 -> parentElement();
newp1 = vec2d(sp1) + vScenePos;
snapOnGrid( newp1 );
vec2d vDir1 = orientation2vec2d(o1);
element = NULL;
if ( isInsideElement( newp1, element1 ) ) element = element1;
else if ( isInsideElement( newp1, element2 ) ) element = element2;
if ( element ) qDebug() <<"Intersection terminal1 : "<< element -> name();
else qDebug() <<"*** Erreur Intersection terminal1 : ";
newp1 = extendOutOfElement( newp1, vDir1, element );
newp2 = vec2d(sp2) + vScenePos;
snapOnGrid( newp2 );
vec2d vDir2 = orientation2vec2d(o2);
element = NULL;
if ( isInsideElement( newp2, element1 ) ) element = element1;
else if ( isInsideElement( newp2, element2 ) ) element = element2;
newp2 = extendOutOfElement( newp2, vDir2, element );
//--------------------------
currentIndice = 0;
addPoint( vec2d(sp1) + vScenePos );
addPoint( newp1 );
vec2d newPt = newp1;
vec2d vo = orientation2vec2d(o1);
// tout droit petite distance
vec2d P1 = vec2d(sp1);
vec2d P2 = vec2d(sp2);
vec2d vDir = vec2d( P1, P2 );
vec2d vNor = vDir.vnormalize();
// printVec2d( "P1", P1);
// printVec2d( "P2", P2);
// printVec2d( "DI", vDir);
// printVec2d( "NO", vNor);
// printDoubl( "dot1", fabs(vNor.dot(vDir1)) );
// printDoubl( "dot2", fabs(vNor.dot(vDir2)) );
// printDoubl( "leng", vDir.length() );
//if ( vDir != vec2d(0.0,0.0) && ( fabs(vNor.dot(vDir1)) != 1.0 || fabs(vNor.dot(vDir2)) != 1.0 || vDir.length() > 45.0 ) ) {
if ( vDir != vec2d(0.0,0.0) && ( vDir.length() > 45.0 ) ) {
while ( newPt != newp2 ) {
if ( bDebug ) {
qDebug() << "**** Point suivant :"<< currentIndice;
printVec2d( " a partir de newPt : ", newPt );
printVec2d( " vers : ", newp2 );
}
newPt = findNextPoint( newPt, vo, newp2, orientation2vec2d(o2) );
addPoint( newPt );
if( currentIndice>=30 ) break;
}
}
else {
qDebug()<<"Tout droit";
vec2ds.removeAt(1);
}
//vec2ds << newp2;
addPoint( vec2d(sp2) + vScenePos );
if ( bSmooth ) smooth();
// change vec2d to QPointF
int nb = vec2ds.size();
for( int i=0; i<nb; i++ ) {
points << vec2ds[i].toQPointF();
}
pointsToSegments(points);
segmentsToPath();
diagram() -> _binaryGrid -> add2grid(this);
if ( Conductor::bDebugGrid ) diagram() -> _binaryGrid -> debugGrid();
}
void Conductor::reBuild() {
if ( ! lastConductor ) return;
lastConductor -> generateConductorPath2( P1, O1, P2, O2 );
}
void Conductor::smooth(){
int nb = vec2ds.size()-4;
vec2d vNull = vec2d(0.0,0.0);
QList<vec2d> removePoints;
for ( int i=1; i<nb; i++ ) {
int ip0 = i;
int ip1 = i+1;
int ip2 = i+2;
int ip3 = i+3;
int ip4 = i+4;
// qDebug() << "------------------------------";
// qDebug() << "i = "<< i;
vec2d v1 = vec2d( vec2ds[ip0], vec2ds[ip1] );
vec2d v2 = vec2d( vec2ds[ip2], vec2ds[ip3] );
vec2d v3 = vec2d( vec2ds[ip1], vec2ds[ip2] );
vec2d v4 = vec2d( vec2ds[ip3], vec2ds[ip4] );
// printVec2d( "v1 : ", v1 );
// printVec2d( "v2 : ", v2 );
// printVec2d( "v3 : ", v3 );
// printVec2d( "v4 : ", v4 );
if ( (v1 == vNull) || (v2 == vNull) || (v3 == vNull) || (v4 == vNull) ) continue;
v1.normalize();
v2.normalize();
v3.normalize();
v4.normalize();
// printVec2d( "v1 : ", v1 );
// printVec2d( "v2 : ", v2 );
// printVec2d( "v3 : ", v3 );
// printVec2d( "v4 : ", v4 );
if ( v1 == v2 && v3 == v4 ) {
vec2d P1 = vec2d( vec2ds[ip1] ) + vec2d( vec2ds[ip2], vec2ds[ip3] );
// printVec2d( "P0 : ", vec2ds[ip0] );
// printVec2d( "P1 : ", P1 );
// printVec2d( "P4 : ", vec2ds[ip4] );
Element * element1 = intersectionElements( P1, vec2ds[ip1] );
Element * element2 = intersectionElements( P1, vec2ds[ip3] );
if ( element1 == NULL && element2 == NULL ){
// removePoints << vec2d( vec2ds[ip1] );
// removePoints << vec2d( vec2ds[ip2] );
//i += 3;
// qDebug() <<"Remove point : "<< ip1 <<", "<< ip2 <<", "<< ip3;
vec2ds[ip1] = P1;
vec2ds[ip2] = P1;
vec2ds[ip3] = P1;
vec2ds.removeAt(ip1);
vec2ds.removeAt(ip1);
smooth();
break;
}
else {
if ( bDebug ) {
if ( element1 ) qDebug() <<"Intersection 1 avec : "<< element1 -> name();
if ( element2 ) qDebug() <<"Intersection 2 avec : "<< element2 -> name();
}
}
}
}
}
/*
"P0 : " ( 220 , 290 )
"P1 : " ( 220 , 470 )
"P4 : " ( 540 , 470 )
*/
void Conductor::updateConductorPath2(const QPointF &p1, Qet::Orientation o1, const QPointF &p2, Qet::Orientation o2) {
generateConductorPath2( p1, o1, p2, o2);
}
/** /**
Dessine le conducteur sans antialiasing. Dessine le conducteur sans antialiasing.
@@ -1278,10 +451,6 @@ void Conductor::paint(QPainter *qp, const QStyleOptionGraphicsItem *options, QWi
// affectation du QPen et de la QBrush modifies au QPainter // affectation du QPen et de la QBrush modifies au QPainter
qp -> setBrush(conductor_brush); qp -> setBrush(conductor_brush);
if ( bMouseOver ) conductor_pen.setWidthF(3.0);
else conductor_pen.setWidthF(1.0);
QPen final_conductor_pen = conductor_pen; QPen final_conductor_pen = conductor_pen;
// modification du QPen generique pour lui affecter la couleur et le style adequats // modification du QPen generique pour lui affecter la couleur et le style adequats
@@ -1346,35 +515,6 @@ void Conductor::paint(QPainter *qp, const QStyleOptionGraphicsItem *options, QWi
qp -> drawEllipse(QRectF(point.x() - pretty_offset, point.y() - pretty_offset, 2.0, 2.0)); qp -> drawEllipse(QRectF(point.x() - pretty_offset, point.y() - pretty_offset, 2.0, 2.0));
} }
} }
//Dessine tous les points
QFont font = qp -> font() ;
font.setPointSize ( 8 );
//font.setWeight(QFont::DemiBold);
qp -> setFont(font);
if ( Conductor::bAffPoint ) {
int nb = vec2ds.size();
vec2d prevPt = vec2d(0.0,0.0);
double nbPt = 0.0;
for (int i = 0 ; i < nb ; i++) {
vec2d pt = vec2ds[i];
vec2d vtl = vec2d(pt) - vec2d( 2.0, 2.0 ); // topLeft
vec2d vbr = vec2d(pt) + vec2d( 2.0, 2.0 ); // bottomRight
if ( prevPt == pt ) nbPt += 1.0;
else nbPt = 0.0;
// Point
QPointF coordText = vec2d( pt + nbPt * vec2d(10.0,0.0) + vec2d(2.0,-1.0) ).toQPointF();
qp -> fillRect( QRectF( vtl.toQPointF(), vbr.toQPointF() ) , square_brush );
// Texte
QString text = QString::number(i,10) +":"+ QString::number( (int)pt.x ) +", "+ QString::number( (int)pt.y );
qp -> drawText( coordText, text );
prevPt = pt;
}
}
qp -> restore(); qp -> restore();
} }
@@ -1572,9 +712,9 @@ void Conductor::hoverLeaveEvent(QGraphicsSceneHoverEvent *e) {
@param e Le QGraphicsSceneHoverEvent decrivant l'evenement @param e Le QGraphicsSceneHoverEvent decrivant l'evenement
*/ */
void Conductor::hoverMoveEvent(QGraphicsSceneHoverEvent *e) { void Conductor::hoverMoveEvent(QGraphicsSceneHoverEvent *e) {
/*
if (isSelected()) { if (isSelected()) {
QPointF hover_point = mapFromScene(e -> pos()) + scenePos(); QPointF hover_point = mapFromScene(e -> pos());
ConductorSegment *segment = segments; ConductorSegment *segment = segments;
bool cursor_set = false; bool cursor_set = false;
while (segment -> hasNextSegment()) { while (segment -> hasNextSegment()) {
@@ -1589,7 +729,7 @@ void Conductor::hoverMoveEvent(QGraphicsSceneHoverEvent *e) {
} }
if (!cursor_set) setCursor(Qt::ArrowCursor); if (!cursor_set) setCursor(Qt::ArrowCursor);
} }
*/
QGraphicsPathItem::hoverMoveEvent(e); QGraphicsPathItem::hoverMoveEvent(e);
} }

53
sources/qetgraphicsitem/conductor.h
View File

@@ -19,7 +19,6 @@
#define CONDUCTOR_H #define CONDUCTOR_H
#include "conductorproperties.h" #include "conductorproperties.h"
#include "Mathlib.h"
class ConductorProfile; class ConductorProfile;
class ConductorSegmentProfile; class ConductorSegmentProfile;
@@ -172,35 +171,6 @@ class Conductor : public QObject, public QGraphicsPathItem {
void saveProfile(bool = true); void saveProfile(bool = true);
void generateConductorPath(const QPointF &, Qet::Orientation, const QPointF &, Qet::Orientation); void generateConductorPath(const QPointF &, Qet::Orientation, const QPointF &, Qet::Orientation);
void updateConductorPath(const QPointF &, Qet::Orientation, const QPointF &, Qet::Orientation); void updateConductorPath(const QPointF &, Qet::Orientation, const QPointF &, Qet::Orientation);
void addPoint(vec2d);
void printVec2d( QString, vec2d );
void printDoubl( QString, double );
vec2d qPointF2vec2d( QPointF );
QPointF vec2d2qPointF( vec2d );
vec2d orientation2vec2d( Qet::Orientation );
void rect2side( vec2d*, vec2d*, QRectF, QPointF );
void rect2side( vec2d*, vec2d*, QRectF );
void rect2corner( vec2d*, vec2d*, vec2d*, vec2d*, QRectF, QPointF );
int sign( double );
int computeSign( vec2d, vec2d, vec2d );
bool isInsideRect( vec2d, vec2d, vec2d );
bool isInsideRect( vec2d, vec2d, vec2d, vec2d );
void computeIntersection( vec2d, vec2d&, vec2d, vec2d );
bool isInsideElement( vec2d, Element* );
Element* intersectionElement( vec2d&, vec2d, Element* );
Element* intersectionElements( vec2d&, vec2d );
void intersectionConductors( vec2d&, vec2d );
void evaluatePath( vec2d, vec2d&, Element*, double = 10.0 );
double computeSensEvaluatePath( vec2d, vec2d, vec2d );
vec2d previousDir();
vec2d findNextPoint( vec2d, vec2d&, vec2d, vec2d );
vec2d extendOutOfElement( vec2d, vec2d, Element* );
void snapOnGrid( vec2d& );
void generateConductorPath2(const QPointF &, Qet::Orientation, const QPointF &, Qet::Orientation);
void smooth( void );
void updateConductorPath2(const QPointF &, Qet::Orientation, const QPointF &, Qet::Orientation);
uint segmentsCount(QET::ConductorSegmentType = QET::Both) const; uint segmentsCount(QET::ConductorSegmentType = QET::Both) const;
QList<QPointF> segmentsToPoints() const; QList<QPointF> segmentsToPoints() const;
QList<ConductorBend> bends() const; QList<ConductorBend> bends() const;
@@ -217,29 +187,6 @@ class Conductor : public QObject, public QGraphicsPathItem {
static qreal conductor_bound(qreal, qreal, bool); static qreal conductor_bound(qreal, qreal, bool);
static Qt::Corner movementType(const QPointF &, const QPointF &); static Qt::Corner movementType(const QPointF &, const QPointF &);
static QPointF movePointIntoPolygon(const QPointF &, const QPainterPath &); static QPointF movePointIntoPolygon(const QPointF &, const QPainterPath &);
QList <vec2d> vec2ds;
vec2d north = vec2d( 0.0,-1.0);
vec2d south = vec2d( 0.0, 1.0);
vec2d east = vec2d( 1.0, 0.0);
vec2d west = vec2d(-1.0, 0.0);
int currentIndice;
// Element elementParent1;
// Element elementParent2;
public:
static bool bAffPoint;
static bool bSmooth;
static bool bDebug;
static bool bDebugGrid;
static int iIndiceDebug;
static Conductor* lastConductor;
static QPointF P1;
static Qet::Orientation O1;
static QPointF P2;
static Qet::Orientation O2;
static void reBuild(void);
inline QList<vec2d> getVec2ds() { return vec2ds; }
}; };
Conductor * longuestConductorInPotential (Conductor *conductor, bool all_diagram = false); Conductor * longuestConductorInPotential (Conductor *conductor, bool all_diagram = false);

3
sources/qetgraphicsitem/conductortextitem.h
View File

@@ -68,8 +68,5 @@ class ConductorTextItem : public DiagramTextItem {
bool moved_by_user_; bool moved_by_user_;
bool rotate_by_user_; bool rotate_by_user_;
QPointF before_mov_pos_; QPointF before_mov_pos_;
}; };
#endif #endif

5
sources/qetgraphicsitem/diagramtextitem.cpp
View File

@@ -73,7 +73,6 @@ void DiagramTextItem::build() {
setFlag(QGraphicsItem::ItemSendsGeometryChanges, true); setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
#endif #endif
connect(this, SIGNAL(lostFocus()), this, SLOT(setNonFocusable())); connect(this, SIGNAL(lostFocus()), this, SLOT(setNonFocusable()));
setAcceptHoverEvents(true);
} }
/** /**
@@ -214,8 +213,7 @@ void DiagramTextItem::setFontSize(int &s) {
@param widget Le QWidget sur lequel on dessine @param widget Le QWidget sur lequel on dessine
*/ */
void DiagramTextItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { void DiagramTextItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) {
painter -> setRenderHint(QPainter::Antialiasing, true); painter -> setRenderHint(QPainter::Antialiasing, false);
//option->
QGraphicsTextItem::paint(painter, option, widget); QGraphicsTextItem::paint(painter, option, widget);
if ( bMouseOver ) { if ( bMouseOver ) {
@@ -234,6 +232,7 @@ void DiagramTextItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *o
painter -> drawRoundRect(boundingRect().adjusted(0, 0, 0, 0), 10, 10); painter -> drawRoundRect(boundingRect().adjusted(0, 0, 0, 0), 10, 10);
painter -> restore(); painter -> restore();
} }
} }
/** /**

1
sources/qetgraphicsitem/diagramtextitem.h
View File

@@ -101,6 +101,5 @@ class DiagramTextItem : public QGraphicsTextItem {
bool no_editable; bool no_editable;
bool m_first_move; bool m_first_move;
QPointF m_mouse_to_origin_movement; QPointF m_mouse_to_origin_movement;
}; };
#endif #endif

17
sources/qetgraphicsitem/element.cpp
View File

@@ -100,7 +100,6 @@ void Element::paint(QPainter *painter, const QStyleOptionGraphicsItem *options,
} }
} }
#endif #endif
if (must_highlight_) drawHighlight(painter, options); if (must_highlight_) drawHighlight(painter, options);
// Dessin de l'element lui-meme // Dessin de l'element lui-meme
@@ -116,18 +115,9 @@ void Element::paint(QPainter *painter, const QStyleOptionGraphicsItem *options,
@return Le rectangle delimitant le contour de l'element @return Le rectangle delimitant le contour de l'element
*/ */
QRectF Element::boundingRect() const { QRectF Element::boundingRect() const {
// qDebug() << QRectF(QPointF(-hotspot_coord.x(), -hotspot_coord.y()), dimensions);
// qDebug() << "orientation : " << orientation();
return(QRectF(QPointF(-hotspot_coord.x(), -hotspot_coord.y()), dimensions)); return(QRectF(QPointF(-hotspot_coord.x(), -hotspot_coord.y()), dimensions));
} }
/**
@return Le rectangle delimitant le contour de l'element
*/
QRectF Element::boundingRectTrue() const {
return mapRectToScene( boundingRect() );
}
/** /**
Definit la taille de l'element sur le schema. Les tailles doivent etre Definit la taille de l'element sur le schema. Les tailles doivent etre
des multiples de 10 ; si ce n'est pas le cas, les dimensions indiquees des multiples de 10 ; si ce n'est pas le cas, les dimensions indiquees
@@ -205,7 +195,6 @@ QPixmap Element::pixmap() {
* @param angle * @param angle
*/ */
void Element::rotateBy(const qreal &angle) { void Element::rotateBy(const qreal &angle) {
qDebug() << "Rotation : " << angle;
qreal applied_angle = QET::correctAngle(angle); qreal applied_angle = QET::correctAngle(angle);
applyRotation(applied_angle + rotation()); applyRotation(applied_angle + rotation());
@@ -274,8 +263,7 @@ void Element::drawSelection(QPainter *painter, const QStyleOptionGraphicsItem *o
t.setStyle(Qt::DashDotLine); t.setStyle(Qt::DashDotLine);
painter -> setPen(t); painter -> setPen(t);
// Le dessin se fait a partir du rectangle delimitant // Le dessin se fait a partir du rectangle delimitant
//painter -> drawRoundRect(boundingRect().adjusted(1, 1, -1, -1), 10, 10); painter -> drawRoundRect(boundingRect().adjusted(1, 1, -1, -1), 10, 10);
painter -> drawRoundRect(boundingRect().adjusted(0, 0, 0, 0), 10, 10);
painter -> restore(); painter -> restore();
} }
@@ -301,8 +289,7 @@ void Element::drawHighlight(QPainter *painter, const QStyleOptionGraphicsItem *o
painter -> setPen(Qt::NoPen); painter -> setPen(Qt::NoPen);
painter -> setBrush(brush); painter -> setBrush(brush);
// Le dessin se fait a partir du rectangle delimitant // Le dessin se fait a partir du rectangle delimitant
//painter -> drawRoundRect(boundingRect().adjusted(1, 1, -1, -1), 10, 10); painter -> drawRoundRect(boundingRect().adjusted(1, 1, -1, -1), 10, 10);
painter -> drawRoundRect(boundingRect().adjusted(0, 0, 0, 0), 10, 10);
painter -> restore(); painter -> restore();
} }

2
sources/qetgraphicsitem/element.h
View File

@@ -150,7 +150,6 @@ class Element : public QetGraphicsItem {
virtual void setHighlighted(bool); virtual void setHighlighted(bool);
void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *); void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *);
QRectF boundingRect() const; QRectF boundingRect() const;
QRectF boundingRectTrue() const;
QSize setSize(int, int); QSize setSize(int, int);
QSize size() const; QSize size() const;
QPixmap pixmap(); QPixmap pixmap();
@@ -182,7 +181,6 @@ class Element : public QetGraphicsItem {
void drawAxes(QPainter *, const QStyleOptionGraphicsItem *); void drawAxes(QPainter *, const QStyleOptionGraphicsItem *);
private: private:
bool bMouseHover;
bool internal_connections_; bool internal_connections_;
bool must_highlight_; bool must_highlight_;
void drawSelection(QPainter *, const QStyleOptionGraphicsItem *); void drawSelection(QPainter *, const QStyleOptionGraphicsItem *);

3
sources/qetgraphicsitem/terminal.cpp
View File

@@ -405,8 +405,7 @@ void Terminal::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
// on s'arrete la s'il n'est pas possible de relier les bornes // on s'arrete la s'il n'est pas possible de relier les bornes
if (!canBeLinkedTo(other_terminal)) return; if (!canBeLinkedTo(other_terminal)) return;
// autrement, on pose un conducteur // autrement, on pose un conducteur
//Conductor *new_conductor = new Conductor(this, other_terminal); Conductor *new_conductor = new Conductor(this, other_terminal);
Conductor *new_conductor = new Conductor(this, other_terminal, d);
new_conductor -> setProperties(d -> defaultConductorProperties); new_conductor -> setProperties(d -> defaultConductorProperties);
d -> undoStack().push(new AddItemCommand<Conductor *>(new_conductor, d)); d -> undoStack().push(new AddItemCommand<Conductor *>(new_conductor, d));
new_conductor -> autoText(); new_conductor -> autoText();

28
sources/qetgraphicsitem/waypoint.cpp
View File

@@ -1,28 +0,0 @@
/*
* waypoint.cpp
*
* Created on: 6 nov. 2014
* Author: rene
*/
#include "waypoint.h"
Waypoint::Waypoint( vec2d o, vec2d d) {
orig = o;
dest = d;
vDir = vec2d( orig, dest );
vNor = vDir.vnormalize();
nexttLeft = NULL;
nexttRight = NULL;
}

33
sources/qetgraphicsitem/waypoint.h
View File

@@ -1,33 +0,0 @@
/*
* waypoint.h
*
* Created on: 6 nov. 2014
* Author: rene
*/
#ifndef WAYPOINT_H_
#define WAYPOINT_H_
#include "Mathlib.h"
class Waypoint;
class Waypoint {
public:
Waypoint(vec2d, vec2d);
~Waypoint();
private:
vec2d next;
vec2d orig;
vec2d dest;
vec2d vDir;
vec2d vNor;
Waypoint* nexttLeft;
Waypoint* nexttRight;
};
#endif /* WAYPOINT_H_ */