HG_REPOSITORIES/LPP/INSTRUMENTATION/kicadtools Commit - r14:72560b13551a

Added Polygon drawing but huge perf issue, to be solved.

jeandet -

r14:72560b13551a default

parent child

Context file:

r14:72560b13551a

test/PCBView/pcbzone.cpp created 644 +62 0

@@ -0,0 +1,62
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the Kicad Tools Software
	3	-- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#include "pcbzone.h"
	23	#include <QPen>
	24	#include <QPixmapCache>
	25
	26	PCBZone::PCBZone(QIlib::QIcadPcbZone zoneNode, PCBContext context)
	27	:QGraphicsItemGroup(),zoneNode(zoneNode),context(context)
	28	{
	29	this->init();
	30	}
	31
	32	void PCBZone::init()
	33	{
	34	this->setFlags(ItemIsMovable\|ItemIsSelectable\|ItemIsFocusable);
	35	QPolygonF poly;
	36	for(int i=0;i<this->zoneNode->filledPolygon.points.points.count();i++)
	37	{
	38	poly.append(this->zoneNode->filledPolygon.points.points.at(i)->pos());
	39	}
	40	QGraphicsPixmapItem* test=new QGraphicsPixmapItem();
	41	QPixmap pix;
	42	QPainter painter;
	43	QGraphicsPolygonItem* polygonItem = new QGraphicsPolygonItem();
	44	QPen pen = polygonItem->pen();
	45	pen.setWidthF(0.01);
	46
	47	polygonItem->setPen(pen);
	48	QBrush brush = polygonItem->brush();
	49	brush.setStyle(Qt::SolidPattern);
	50	brush.setColor(context->layerColor(this->zoneNode->layer.value()));
	51	polygonItem->setBrush(brush);
	52	polygonItem->setZValue(-context->layer(this->zoneNode->layer.value()));
	53	polygonItem->setPolygon(poly);
	54	polygonItem->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
	55	// test->setPixmap(polygonItem->);
	56	//voir doc/qt/...
	57	// polygonItem->paint();
	58	this->addToGroup(polygonItem);
	59
	60	this->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
	61	setOpacity(0.6);
	62	}

test/PCBView/pcbzone.h created 644 +43 0

@@ -0,0 +1,43
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the Kicad Tools Software
	3	-- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#ifndef PCBZONE_H
	23	#define PCBZONE_H
	24	#include <QObject>
	25	#include <QWidget>
	26	#include <QGraphicsRectItem>
	27	#include <QGraphicsItemGroup>
	28	#include <pcbcontext.h>
	29	#include <qicadpcb.h>
	30	#include <QPainterPath>
	31
	32	class PCBZone: public QGraphicsItemGroup
	33	{
	34	public:
	35	PCBZone(QIlib::QIcadPcbZone* zoneNode,PCBContext* context);
	36	private:
	37	void init();
	38	QIlib::QIcadPcbZone* zoneNode;
	39	int layer;
	40	PCBContext* context;
	41	};
	42
	43	#endif // PCBZONE_H

qilib/qicadlisplikelexique.cpp +4 0

             const char*    feature2_c  =  "(feature2";
             const char*    field_c  =  "(field";
             const char*    fields_c  =  "(fields";
+            const char*    filled_polygon_c  =  "(filled_polygon";
             const char*    font_c  =  "(font";
             const char*    fp_circle_c  =  "(fp_circle";
             const char*    fp_line_c  =  "(fp_line";
             const char*    plotothertext_c  =  "(plotothertext";
             const char*    plotreference_c  =  "(plotreference";
             const char*    plotvalue_c  =  "(plotvalue";
+            const char*    polygon_c  =  "(polygon";
             const char*    psa4output_c  =  "(psa4output";
             const char*    psnegative_c  =  "(psnegative";
+            const char*    pts_c  =  "(pts";
             const char*    ref_c  =  "(ref";
             const char*    rotate  =  "(rota";
             const char*    scale_c  =  "(scale";
             const char*    visible_elements_c  =  "(visible_elements";
             const char*    width_c  =  "(width";
             const char*    xyz  =  "(x";
+            const char*    xy_c  =  "(xy";
             const char*    zone_45_only_c  =  "(zone_45_only";
             const char*    zone_clearance_c  =  "(zone_clearance";
             const char*    zone_c  =  "(zone";

qilib/qicadlisplikelexique.h +4 0

             extern "C" const char*   feature2_c;
             extern "C" const char*   field_c;
             extern "C" const char*   fields_c;
+            extern "C" const char*   filled_polygon_c;
             extern "C" const char*   font_c;
             extern "C" const char*   fp_circle_c;
             extern "C" const char*   fp_line_c;
             extern "C" const char*   plotothertext_c;
             extern "C" const char*   plotreference_c;
             extern "C" const char*   plotvalue_c;
+            extern "C" const char*   polygon_c;
             extern "C" const char*   psa4output_c;
             extern "C" const char*   psnegative_c;
+            extern "C" const char*   pts_c;
             extern "C" const char*   ref_c;
             extern "C" const char*   rotate;
             extern "C" const char*   scale_c;
             extern "C" const char*   visible_elements_c;
             extern "C" const char*   width_c;
             extern "C" const char*   xyz;
+            extern "C" const char*   xy_c;
             extern "C" const char*   zone_45_only_c;
             extern "C" const char*   zone_clearance_c;
             extern "C" const char*   zone_c;

qilib/qicadpcb.cpp +113 0

@@ -1120,10 +1120,118 void QIlib::QIcadPcbZone::setNode(QIlib:
1120	if(node->name==QIlib::Lexique::zone_c)	1120	if(node->name==QIlib::Lexique::zone_c)
1121	{	1121	{
1122	this->p_node = node;	1122	this->p_node = node;
		1123	for(int i=0;i<node->nodes.count();i++)
		1124	{
		1125	if(node->nodes.at(i)->name==QIlib::Lexique::polygon_c)
		1126	{
		1127	this->polygon.setNode(node->nodes.at(i));
		1128	}
		1129	if(node->nodes.at(i)->name==QIlib::Lexique::filled_polygon_c)
		1130	{
		1131	this->filledPolygon.setNode(node->nodes.at(i));
		1132	}
		1133	if(node->nodes.at(i)->name==QIlib::Lexique::layer_c)
		1134	{
		1135	this->layer.setNode(node->nodes.at(i));
		1136	}
		1137	}
		1138	}
		1139	}
		1140
		1141
		1142	QIlib::QIcadPcbPolygonPoint::QIcadPcbPolygonPoint(QIlib::AbstractNode *node)
		1143	:QIcadAbstractNodeWrapper(node)
		1144	{
		1145	this->p_pos.setX(0.0);
		1146	this->p_pos.setY(0.0);
		1147	this->setNode(node);
		1148	}
		1149
		1150	void QIlib::QIcadPcbPolygonPoint::setNode(QIlib::AbstractNode *node)
		1151	{
		1152	if(node->name==QIlib::Lexique::xy_c)
		1153	{
		1154	this->p_node = node;
		1155	this->p_pos = nodeTo2DCoords(node);
1123	}	1156	}
1124	}	1157	}
1125		1158
1126		1159
		1160	QIlib::QIcadPcbPolygon::QIcadPcbPolygon(QIlib::AbstractNode *node)
		1161	:QIcadAbstractNodeWrapper(node)
		1162	{
		1163	this->setNode(node);
		1164	}
		1165
		1166	void QIlib::QIcadPcbPolygon::setNode(QIlib::AbstractNode *node)
		1167	{
		1168	if(node->name==QIlib::Lexique::polygon_c)
		1169	{
		1170	this->p_node = node;
		1171	this->p_filled = false;
		1172	for(int i=0;i<node->nodes.count();i++)
		1173	{
		1174	if(node->nodes.at(i)->name==QIlib::Lexique::pts_c)
		1175	{
		1176	this->points.setNode(node->nodes.at(i));
		1177	}
		1178	}
		1179	}
		1180	if(node->name==QIlib::Lexique::filled_polygon_c)
		1181	{
		1182	this->p_node = node;
		1183	this->p_filled = true;
		1184	for(int i=0;i<node->nodes.count();i++)
		1185	{
		1186	if(node->nodes.at(i)->name==QIlib::Lexique::pts_c)
		1187	{
		1188	this->points.setNode(node->nodes.at(i));
		1189	}
		1190	}
		1191	}
		1192	}
		1193
		1194	QIlib::QIcadPcbPolygonPoints::QIcadPcbPolygonPoints(QIlib::AbstractNode *node)
		1195	:QIcadAbstractNodeWrapper(node)
		1196	{
		1197	this->setNode(node);
		1198	}
		1199
		1200	void QIlib::QIcadPcbPolygonPoints::setNode(QIlib::AbstractNode *node)
		1201	{
		1202	this->clrPoints();
		1203	if(node->name==QIlib::Lexique::pts_c)
		1204	{
		1205	this->p_node = node;
		1206	for(int i=0;i<node->nodes.count();i++)
		1207	{
		1208	if(node->nodes.at(i)->name==QIlib::Lexique::xy_c)
		1209	{
		1210	this->apendPoint(node->nodes.at(i));
		1211	}
		1212	}
		1213	}
		1214	}
		1215
		1216	void QIlib::QIcadPcbPolygonPoints::clrPoints()
		1217	{
		1218	while(points.count())
		1219	{
		1220	QIcadPcbPolygonPoint* point;
		1221	point = points.last();
		1222	points.removeLast();
		1223	delete point;
		1224	}
		1225	}
		1226
		1227	void QIlib::QIcadPcbPolygonPoints::apendPoint(QIlib::AbstractNode *node)
		1228	{
		1229	if(node->name==QIlib::Lexique::xy_c)
		1230	{
		1231	this->points.append(new QIcadPcbPolygonPoint(node));
		1232	}
		1233	}
		1234
1127	const QPointF QIlib::nodeTo2DCoords(QIlib::AbstractNode *node)	1235	const QPointF QIlib::nodeTo2DCoords(QIlib::AbstractNode *node)
1128	{	1236	{
1129	QPointF point;	1237	QPointF point;
@@ -1193,3 +1301,8 const QSizeF QIlib::nodeTo2DSize(QIlib::
1193	}	1301	}
1194	return size;	1302	return size;
1195	}	1303	}
		1304
		1305
		1306
		1307
		1308

qilib/qicadpcb.h +41 0

@@ -363,11 +363,52 public:
363	void setNode(QIlib::AbstractNode* node);	363	void setNode(QIlib::AbstractNode* node);
364	};	364	};
365		365
		366
		367	class QIcadPcbPolygonPoint : public QIcadAbstractNodeWrapper
		368	{
		369	public:
		370	QIcadPcbPolygonPoint(QIlib::AbstractNode* node);
		371	QIcadPcbPolygonPoint(){}
		372	void setNode(QIlib::AbstractNode* node);
		373	const QPointF& pos(){return p_pos;}
		374	private:
		375	QPointF p_pos;
		376	};
		377
		378
		379	class QIcadPcbPolygonPoints : public QIcadAbstractNodeWrapper
		380	{
		381	public:
		382	QIcadPcbPolygonPoints(QIlib::AbstractNode* node);
		383	QIcadPcbPolygonPoints(){}
		384	void setNode(QIlib::AbstractNode* node);
		385	QList<QIcadPcbPolygonPoint*> points;
		386	void clrPoints();
		387	void apendPoint(QIlib::AbstractNode* node);
		388	private:
		389	QPointF p_pos;
		390	};
		391
		392	class QIcadPcbPolygon : public QIcadAbstractNodeWrapper
		393	{
		394	public:
		395	QIcadPcbPolygon(QIlib::AbstractNode* node);
		396	QIcadPcbPolygon(){}
		397	QIcadPcbPolygonPoints points;
		398	void setNode(QIlib::AbstractNode* node);
		399	bool isFilled(){return p_filled;}
		400	private:
		401	bool p_filled;
		402	};
		403
366	class QIcadPcbZone : public QIcadAbstractNodeWrapper	404	class QIcadPcbZone : public QIcadAbstractNodeWrapper
367	{	405	{
368	public:	406	public:
369	QIcadPcbZone(QIlib::AbstractNode* node);	407	QIcadPcbZone(QIlib::AbstractNode* node);
370	QIcadPcbZone(){}	408	QIcadPcbZone(){}
		409	QIcadPcbPolygon polygon;
		410	QIcadPcbPolygon filledPolygon;
		411	QIcadAbstractNodeWrapper layer;
371	void setNode(QIlib::AbstractNode* node);	412	void setNode(QIlib::AbstractNode* node);
372	};	413	};
373		414

test/PCBView/PCBView.pro +6 -4

             SOURCES += main.cpp\
                     mainwindow.cpp \
                 pcbgraphicview.cpp \
-                pcbrectpad.cpp \
                 pcbmodule.cpp \
                 pcbline.cpp \
                 pcbcontext.cpp \
-                pcbvia.cpp
+                pcbvia.cpp \
+                pcbpad.cpp \
+                pcbzone.cpp
             HEADERS  += mainwindow.h \
                 pcbgraphicview.h \
-                pcbrectpad.h \
                 pcbmodule.h \
                 pcbline.h \
                 pcbcontext.h \
-                pcbvia.h
+                pcbvia.h \
+                pcbpad.h \
+                pcbzone.h
             FORMS    += mainwindow.ui

test/PCBView/mainwindow.cpp +6 -3

             #include "pcbmodule.h"
             #include "pcbline.h"
             #include "pcbvia.h"
+            #include "pcbzone.h"
             #include <QFileDialog>
             {
                 ui->setupUi(this);
                 this->p_scene = new QGraphicsScene();
+            //    this->p_scene->setItemIndexMethod(QGraphicsScene::NoIndex);
                 this->context = new PCBContext();
                 this->ui->graphicsView->setScene(this->p_scene);
                 this->pcbDriver =NULL;
                 pcbDriver = new QIlib::QIcadPcb();
                 this->context->clear();
                 this->p_scene->clear();
-            //    pcbDriver.parsePcb("/opt/kicadTools/test/testFiles/pcb2.kicad_pcb");
-            //    pcbDriver.parsePcb("/home/jeandet/Documents/PCB/ADC_STAMP/ADC_STAMP.kicad_pcb");
                 pcbDriver->parsePcb(file);
-            //    pcbDriver.parsePcb("/usr/share/kicad/demos/kit-dev-coldfire-xilinx_5213/kit-dev-coldfire-xilinx_5213.kicad_pcb");
                 for(int i=0;i<pcbDriver->pcbRoot->layers.layers.count();i++)
                 {
                     this->context->addlayer(pcbDriver->pcbRoot->layers.layers.at(i)->name(),pcbDriver->pcbRoot->layers.layers.at(i)->index());
                 {
                     this->p_scene->addItem(new PCBVia(pcbDriver->pcbRoot->vias.at(i),this->context));
                 }
+                for(int i=0;i<pcbDriver->pcbRoot->zones.count();i++)
+                {
+                    this->p_scene->addItem(new PCBZone(pcbDriver->pcbRoot->zones.at(i),this->context));
                 }
+            }

test/PCBView/pcbgraphicview.cpp +6 -4

             #include <math.h>
             #include <QGLWidget>
+            #include <QOpenGLWidget>
+            #include <QPixmapCache>
             PCBGraphicView::PCBGraphicView(QWidget *parent)
                 :QGraphicsView(parent)
             {
                 this->setRenderHint(QPainter::Antialiasing, true);
                 this->setDragMode(QGraphicsView::RubberBandDrag);
                 this->setOptimizationFlags(QGraphicsView::DontSavePainterState);
                 this->setTransformationAnchor(AnchorUnderMouse);
                 this->scale(qreal(0.8), qreal(0.8));
                 this->setRubberBandSelectionMode(Qt::ContainsItemBoundingRect);
-                this->setDragMode(RubberBandDrag);
                 this->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 this->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+            //    this->setViewport(new QOpenGLWidget());
+                QPixmapCache::setCacheLimit(1024*1024*4);
                 this->ctrl_pressed = false;
                 this->shift_pressed = false;
             }
             void PCBGraphicView::wheelEvent(QWheelEvent *event)
             {
                     if (event->modifiers() & Qt::ControlModifier)
                     {
+                        event->accept();
                         if (event->orientation()== Qt::Vertical)
                             scaleView(pow((double)2, event->delta() / 240.0));
                     }
                     {
                         if (event->modifiers() & Qt::ShiftModifier)
                         {
+                            event->accept();
                             QWheelEvent* tempevent = new QWheelEvent(event->pos(),(event->delta()/10),event->buttons(),event->modifiers(),Qt::Horizontal);
                             QGraphicsView::wheelEvent(tempevent);
                         }

test/PCBView/pcbgraphicview.h +1 0

             #include <QKeyEvent>
             #include <QPainter>
             #include <QMap>
+            #include <QElapsedTimer>
             class PCBGraphicView : public QGraphicsView
             {

test/PCBView/pcbmodule.cpp +2 -4

             ----------------------------------------------------------------------------*/
             #include "pcbmodule.h"
             #include "pcbline.h"
-            #include "pcbrectpad.h"
+            #include "pcbpad.h"
             PCBModule::PCBModule(QIlib::QIcadPcbModule *moduleNode, PCBContext *context)
                 :QGraphicsItemGroup(),context(context)
             {
                 this->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
                 this->setFlags(ItemIsMovable|ItemIsSelectable|ItemIsFocusable);
-            //    this->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
-            //    this->addToGroup(new QGraphicsRectItem(0,0,2,2));
                 this->setPos(moduleNode->pos());
                 for(int i=0;i<moduleNode->fp_lines.count();i++)
                 {
                 }
                 for(int i=0;i<moduleNode->pads.count();i++)
                 {
-                    this->addToGroup(new PCBRectPad((QIlib::QIcadPcbPad*)moduleNode->pads.at(i),moduleNode->pos(),context));
+                    this->addToGroup(new PCBPad((QIlib::QIcadPcbPad*)moduleNode->pads.at(i),moduleNode->pos(),context));
                 }
                 this->setRotation(moduleNode->angle());
             }

test/PCBView/pcbpad.cpp ~~test/PCBView/pcbrectpad.cpp~~ renamed +4 -4

             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
-            #include "pcbrectpad.h"
+            #include "pcbpad.h"
             #include <QPen>
-            PCBRectPad::PCBRectPad(QIlib::QIcadPcbPad *padNode, PCBContext *context)
+            PCBPad::PCBPad(QIlib::QIcadPcbPad *padNode, PCBContext *context)
                 :QGraphicsItemGroup(),padNode(padNode),context(context)
             {
                 this->init(QPointF(0.0,0.0));
-            PCBRectPad::PCBRectPad(QIlib::QIcadPcbPad *padNode, QPointF offset, PCBContext *context)
+            PCBPad::PCBPad(QIlib::QIcadPcbPad *padNode, QPointF offset, PCBContext *context)
                 :QGraphicsItemGroup(),padNode(padNode),context(context)
             {
                 this->init(offset);
             }
-            void PCBRectPad::init( QPointF offset)
+            void PCBPad::init( QPointF offset)
             {
                 this->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
                 offset-=QPointF(this->padNode->size().width()/2,this->padNode->size().height()/2);

test/PCBView/pcbpad.h ~~test/PCBView/pcbrectpad.h~~ renamed +6 -6

             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
-            #ifndef PCBRECTPAD_H
+            #ifndef PCBPAD_H
-            #define PCBRECTPAD_H
+            #define PCBPAD_H
             #include <QObject>
             #include <QWidget>
             #include <pcbcontext.h>
             #include <qicadpcb.h>
-            class PCBRectPad : public QGraphicsItemGroup
+            class PCBPad : public QGraphicsItemGroup
             {
             public:
-                PCBRectPad(QIlib::QIcadPcbPad* padNode,PCBContext* context);
+                PCBPad(QIlib::QIcadPcbPad* padNode,PCBContext* context);
-                PCBRectPad(QIlib::QIcadPcbPad* padNode,QPointF offset,PCBContext* context);
+                PCBPad(QIlib::QIcadPcbPad* padNode,QPointF offset,PCBContext* context);
             private:
                 void init(QPointF offset);
                 PCBContext* context;
             };
-            #endif // PCBRECTPAD_H
+            #endif // PCBPAD_H

test/PCBView/pcbvia.cpp +2 -2

             void PCBVia::init(QPointF offset)
             {
+                this->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+                this->setFlags(ItemIsMovable|ItemIsSelectable|ItemIsFocusable);
                 this->path.addEllipse(this->viaNode->pos(),this->viaNode->size().width()/2,this->viaNode->size().height()/2);
                 double thickness = (this->viaNode->size().width()-this->viaNode->drill())/2;
                 this->path.addEllipse(this->viaNode->pos(),(this->viaNode->size().width()/2)-thickness,(this->viaNode->size().height()/2)-thickness);
-                this->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
-                this->setFlags(ItemIsMovable|ItemIsSelectable|ItemIsFocusable);
                 offset-=QPointF(this->viaNode->size().width()/2,this->viaNode->size().height()/2);
                 for(int i=0;i<this->viaNode->layers().count();i++)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages