ProgrammingExamples - New pages [en]

CPP/OpenMP/ParallelFor

2016-11-22T01:21:49Z

Daviddoria: Created page with "==ParallelFor.cpp== <source lang="cpp"> #include <iostream> int main(int,char*[]) { #pragma omp parallel for for(int x=0; x < 100; x++) { std::cout << x <..."

==ParallelFor.cpp==
<source lang="cpp">
#include <iostream>

int main(int,char*[])
{
#pragma omp parallel for
for(int x=0; x < 100; x++)
{
std::cout << x << std::endl;
}
return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(ParallelFor)

SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -std=c++11")

find_package(OpenMP REQUIRED)

IF(OPENMP_FOUND)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
else()
message(WARNING "OpenMP not available!")
endif()

ADD_EXECUTABLE(ParallelFor ParallelFor.cpp)

</source>

OpenMP

2016-11-22T01:21:07Z

Daviddoria: Created page with "Simple OpenMP examples. * Perform a parallel for loop"

Simple OpenMP examples.

* [[CPP/OpenMP/ParallelFor|Perform a parallel for loop]]

CPP/decltype

2016-11-20T12:59:08Z

Daviddoria: Created page with "==decltype.cpp== <source lang="cpp"> #include <iostream> void variable() { float a = 1.2f; decltype(a) b = a + .3; std::cout << b << std::endl; } float f() {..."

==decltype.cpp==
<source lang="cpp">
#include <iostream>

void variable()
{
float a = 1.2f;

decltype(a) b = a + .3;

std::cout << b << std::endl;
}

float f()
{
return 1.2f;
}

void func()
{
decltype(f()) b = f() + .3;

std::cout << b << std::endl;
}

int main(int,char*[])
{
variable();
func();

return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(decltype)

SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -std=c++11")

ADD_EXECUTABLE(decltype decltype.cpp)

</source>

CPP/bind

2016-11-19T13:49:55Z

Daviddoria: Created page with "==bind.cpp== <source lang="cpp"> #include <iostream> #include <functional> void add(int a, int b) { std::cout << "a: " << a << " b: " << b << std::endl; } int main(int,c..."

==bind.cpp==
<source lang="cpp">
#include <iostream>
#include <functional>

void add(int a, int b)
{
std::cout << "a: " << a << " b: " << b << std::endl;
}

int main(int,char*[])
{
// free function, full call
{
std::function<void(int, int)> f = std::bind(add, std::placeholders::_1, std::placeholders::_2);
f(1,2);
}

// free function, partial-arg call
{
std::function<void(int)> f = std::bind(add, 1, std::placeholders::_1);
f(2);
}

// free function, no-arg call
{
std::function<void()> f = std::bind(add, 1, 2);
f();
}

return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(bind)

SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -std=c++11")

ADD_EXECUTABLE(bind bind.cpp)
</source>

CPP/Boost/BGL/PrimMST

2016-11-10T11:45:19Z

Daviddoria:

==PrimMST.cpp==
<source lang="cpp">
#include <iostream>

#include <boost/graph/graph_traits.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/prim_minimum_spanning_tree.hpp>

using EdgeWeightProperty = boost::property<boost::edge_weight_t, double>;

using GraphType = boost::adjacency_list<boost::setS, // OutEdgeContainer
boost::vecS, // VertexContainer
boost::undirectedS, boost::no_property, EdgeWeightProperty> ;

using PredecessorContainer = std::vector<boost::graph_traits < GraphType >::vertex_descriptor>;

GraphType CreateGraphFromPredecessors(const PredecessorContainer& predecessors)
{
GraphType g(predecessors.size());

for(unsigned int vertexID = 0; vertexID < predecessors.size(); ++vertexID) {
if(predecessors[vertexID] != vertexID) {
add_edge(predecessors[vertexID], vertexID, g);
}
}

return g;
}

void PrintEdges(GraphType g)
{
typedef boost::graph_traits<GraphType>::edge_iterator edge_iter;
std::pair<edge_iter, edge_iter> edgePair;
for(edgePair = edges(g); edgePair.first != edgePair.second; ++edgePair.first) {
std::cout << *(edgePair.first) << std::endl;
}

std::cout << std::endl;
}

int main(int,char*[])
{
// Create a graph object
GraphType g(3);

// Create a "triangle"

EdgeWeightProperty weight0 = 5;
add_edge(0, 1, weight0, g);

EdgeWeightProperty weight1 = 3;
add_edge(1, 2, weight1, g);

EdgeWeightProperty weight2 = 4;
add_edge(0, 2, weight2, g);

PrintEdges(g);

// Create a container to store the predecessors for each vertex. Upon completion of the algorithm, the edges (p[u],u) for all u in V are in the minimum spanning tree.
PredecessorContainer predecessors(num_vertices(g));

// "named parameter" signature
prim_minimum_spanning_tree(g, &predecessors[0], boost::root_vertex(1));

for (std::size_t i = 0; i != predecessors.size(); ++i) {

if (predecessors[i] != i) {
std::cout << "parent[" << i << "] = " << predecessors[i] << std::endl;
}
else {
std::cout << "parent[" << i << "] = no predecessors (i.e. root node)" << std::endl;
}
}

GraphType mst = CreateGraphFromPredecessors(predecessors);

PrintEdges(mst);

return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(PrimMST)

set(Boost_USE_MULTITHREADED ON)
FIND_PACKAGE(Boost 1.38 COMPONENTS program_options required)

INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${Boost_INCLUDE_DIRS})
LINK_DIRECTORIES(${LINK_DIRECTORIES} ${Boost_LIBRARY_DIRS})

ADD_EXECUTABLE(PrimMST PrimMST.cpp)

</source>

OpenCV/ImageProcessing/ExtractChannel

2015-05-15T13:02:35Z

Daviddoria: Created page with "You will want to make sure that you include the imgproc, highgui, and core, libraries in your project settings. ==ExtractChannel.cpp== <source lang="cpp"> #include "highgui.h..."

You will want to make sure that you include the imgproc, highgui, and core, libraries in your project settings.

==ExtractChannel.cpp==
<source lang="cpp">
#include "highgui.h" // required for imread()
#include "cv.h"

#include <iostream>
#include <vector>

int main(int, char*argv[])
{
cv::Mat image = cv::imread(argv[1], CV_LOAD_IMAGE_COLOR);

if(image.empty())
{
std::cout << "Can't read the image" << std::endl;
return -1;
}
std::vector<cv::Mat> channels;
cv::split(image, channels);
cv::Mat r_channel = channels[0];

for(int i=0; i < r_channel.rows; i++)
{
for(int j=0; j < r_channel.cols; j++)
{
std::cout << r_channel.at<uchar>(i,j) << std::endl;
}
}

return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(ExtractChannel)

FIND_PACKAGE(OpenCV REQUIRED )
INCLUDE_DIRECTORIES( ${OPENCV_INCLUDE_DIR} )

ADD_EXECUTABLE(ExtractChannel ExtractChannel.cpp)
TARGET_LINK_LIBRARIES(ExtractChannel ${OpenCV_LIBS})
</source>

CPP/Eigen/SimplicialLDLT

2015-05-15T10:20:17Z

Daviddoria: Created page with "==SimplicialLDLT.cpp== <source lang="cpp"> #include <iostream> #include <Eigen/Sparse> int main(int, char *[]) { // Create matrix typedef Eigen::SparseMatrix<double> Spa..."

==SimplicialLDLT.cpp==
<source lang="cpp">
#include <iostream>

#include <Eigen/Sparse>

int main(int, char *[])
{
// Create matrix
typedef Eigen::SparseMatrix<double> SparseMatrixType;
SparseMatrixType A(2, 2);

// Create the right-hand-side vector
Eigen::VectorXd b(2);

// Fill matrix
A.coeffRef(0, 0) += 1;
A.coeffRef(1, 1) += 3;

// Fill vector
b[0] = 1;
b[1] = 2;

// Solve the (symmetric) system
Eigen::SimplicialLDLT<SparseMatrixType> sparseSolver(A);
Eigen::VectorXd x = sparseSolver.solve(b);
if(sparseSolver.info() != Eigen::Success)
{
throw std::runtime_error("Decomposition failed!");
}

std::cout << "Result: " << x << std::endl;

return EXIT_SUCCESS;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(SimplicialLDLT)

# Set the CMake variable to the value of the environment variable.
# If the build is absolutely fresh, this will be the case if the CMake variable EIGEN3_INCLUDE_DIR is not set.
if(NOT EIGEN3_INCLUDE_DIR)
set(EIGEN3_INCLUDE_DIR $ENV{EIGEN3_INCLUDE_DIR})
message("Set EIGEN3_INCLUDE_DIR to ${EIGEN3_INCLUDE_DIR} from environment variable of the same name.")
else()
message("EIGEN3_INCLUDE_DIR is ${EIGEN3_INCLUDE_DIR}")
endif()

if(NOT EIGEN3_FOUND)
FIND_PACKAGE(Eigen3 REQUIRED) #requires FindEigen3.cmake to be in the source directory
include_directories(${EIGEN3_INCLUDE_DIR})
endif()

ADD_EXECUTABLE(SimplicialLDLT SimplicialLDLT.cpp )

</source>

CPP/Boost/ClassFunctionPointer

2015-05-12T19:36:36Z

Daviddoria: /* CMakeLists.txt */

==ClassFunctionPointer.cpp==
<source lang="cpp">
#include <boost/function.hpp>
#include <boost/bind.hpp>

#include <iostream>

class MyClass
{
private:
double Update1()
{
std::cout << "Update1" << std::endl;
}
double Update2()
{
std::cout << "Update2" << std::endl;
}

public:
boost::function< double() > Update;
void SetUpdateMethod(int method)
{
if(method == 1)
{
this->Update = boost::bind(&MyClass::Update1,this);
}
if(method == 2)
{
this->Update = boost::bind(&MyClass::Update2,this);
}
}
};

int main ()
{
MyClass a;
a.SetUpdateMethod(1);
a.Update();

a.SetUpdateMethod(2);
a.Update();

return 0;
}
</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(ClassFunctionPointer)
ADD_EXECUTABLE(ClassFunctionPointer ClassFunctionPointer.cpp)
</source>

Matlab/ReadTextFile

2013-03-21T15:38:47Z

Daviddoria: Created page with '==ReadTextFile.m== <source lang="bash"> data=textread('LocalizationError.txt'); plot(data(:,1), data(:,2)) </source>'

==ReadTextFile.m==
<source lang="bash">
data=textread('LocalizationError.txt');
plot(data(:,1), data(:,2))
</source>

Matlab

2013-03-21T15:38:07Z

Daviddoria: Created page with '* Read a space separated text file into a matrix'

* [[Matlab/ReadTextFile|Read a space separated text file into a matrix]]

CPP/Boost/Geometry/CoordinateConversion

2012-09-25T17:45:50Z

Daviddoria: Created page with '==Spherical.cpp== <source lang="cpp"> #include <boost/geometry/geometry.hpp> #include <iostream> static void CartesianToSpherical(); static void SphericalToCartesian(); int ma…'

==Spherical.cpp==
<source lang="cpp">
#include <boost/geometry/geometry.hpp>

#include <iostream>

static void CartesianToSpherical();
static void SphericalToCartesian();

int main()
{
CartesianToSpherical();
SphericalToCartesian();
}

void CartesianToSpherical()
{
std::cout << "CartesianToSpherical()" << std::endl;
namespace bg = boost::geometry; // bg = 'B'oost 'G'eometry
namespace cs = bg::cs; // cs = 'C'oordinate 'S'ystem

typedef bg::model::point<long double, 3, cs::cartesian> CartesianType;
CartesianType cartesian(0.084186, 0.0225576, 0.996195);

typedef bg::model::point<long double, 2, cs::spherical<bg::degree> > SphericalType;
SphericalType spherical;

bg::strategy::transform::from_cartesian_3_to_spherical_polar_2<CartesianType, SphericalType> strategy;
bg::transform(cartesian, spherical, strategy);

std::cout
<< "cartesian: " << bg::dsv(cartesian) << std::endl // dsv = Delimiter Separated Values
<< "spherical: " << bg::dsv(spherical) << std::endl;
}

void SphericalToCartesian()
{
std::cout << "SphericalToCartesian()" << std::endl;
namespace bg = boost::geometry; // bg = 'B'oost 'G'eometry
namespace cs = bg::cs; // cs = 'C'oordinate 'S'ystem

// (theta=5.0, phi=15.0)
typedef bg::model::point<long double, 2, cs::spherical<bg::degree> > SphericalType;
SphericalType spherical(15.0, 5.0);

typedef bg::model::point<long double, 3, cs::cartesian> CartesianType;
CartesianType cartesian;

bg::strategy::transform::from_spherical_polar_2_to_cartesian_3<SphericalType, CartesianType> strategy;
bg::transform(spherical, cartesian, strategy);

std::cout
<< "spherical: " << bg::dsv(spherical) << std::endl // dsv = Delimiter Separated Values
<< "cartesian: " << bg::dsv(cartesian) << std::endl;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(Spherical)

set(Boost_USE_MULTITHREADED ON)
FIND_PACKAGE(Boost 1.38 COMPONENTS required)

INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${Boost_INCLUDE_DIRS})
LINK_DIRECTORIES(${LINK_DIRECTORIES} ${Boost_LIBRARY_DIRS})

ADD_EXECUTABLE(Spherical Spherical.cpp)
</source>

Qt/Utilities/Settings

2012-09-18T15:32:50Z

Daviddoria: Created page with '==Settings.cpp== <source lang="cpp"> #include <QtCore> #include <iostream> void LocalUsage(); void GlobalUsage(); int main(int argc, char *argv[]) { QCoreApplication app(arg…'

==Settings.cpp==
<source lang="cpp">
#include <QtCore>

#include <iostream>

void LocalUsage();
void GlobalUsage();

int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);

LocalUsage();
GlobalUsage();

return 0;
}

void LocalUsage()
{
QSettings settings("MyCompany", "MyProgram");
QString hello = "Hello, world!";
// store a value
settings.setValue("Greeting", hello); // creates ~/.config/OpenSourcePress/ConfigTest.conf

// reset variable
hello = "";
// read value and assign to variable
hello = settings.value("Greeting").toString();
std::cout << hello.toStdString() << std::endl; // prints "Hello, world!"

}

void GlobalUsage()
{
QCoreApplication::setOrganizationName("MyCompany");
//QCoreApplication::setOrganizationDomain("mysoft.com");
QCoreApplication::setApplicationName("MyProgram");

QSettings settings;
QString hello = "Hello, world!";
// store a value
settings.setValue("Greeting", hello); // creates ~/.config/OpenSourcePress/ConfigTest.conf

// reset variable
hello = "";
// read value and assign to variable
hello = settings.value("Greeting").toString();
std::cout << hello.toStdString() << std::endl; // prints "Hello, world!"
}
</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(Settings)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

INCLUDE_DIRECTORIES(${QT_QTXML_INCLUDE_DIR}) # Prevents "QtXml: No such file or directory"

ADD_EXECUTABLE(Settings Settings.cpp)
message(${QT_LIBRARIES})
TARGET_LINK_LIBRARIES(Settings ${QT_LIBRARIES})

</source>

Building on Windows

2012-09-16T17:42:53Z

Daviddoria:

A typical CMakeLists.txt file on this site looks like this:

<source lang="cmake">
cmake_minimum_required(VERSION 2.6)
PROJECT(FileMenu)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs main.ui)
QT4_WRAP_CPP(MOCSrcs filemenu.h)

include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(FileMenu main.cpp filemenu.h filemenu.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(FileMenu ${QT_LIBRARIES})
</source>

However, when you build and run in Windows, you will get a console window that appears along with your GUI program. To fix this, you must do two things. First, add ${QT_QTMAIN_LIBRARY} to your target_link_libraries command. Second, you must specify /SUBSYSTEM:WINDOWS for all build configurations (Release, Debug, etc) that you want to not pop up the console window. An example is below, where when built in release mode, no console will appear:

<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(FileMenu)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs main.ui)
QT4_WRAP_CPP(MOCSrcs filemenu.h)

include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(FileMenu main.cpp filemenu.h filemenu.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(FileMenu ${QT_QTMAIN_LIBRARY} ${QT_LIBRARIES})

set_target_properties(FileMenu PROPERTIES LINK_FLAGS_RELEASE "/SUBSYSTEM:WINDOWS")

</source>

If you want to set this for all build modes, simply use:
<source lang="cmake">
set_target_properties(FileMenu PROPERTIES LINK_FLAGS "/SUBSYSTEM:WINDOWS") # works for all build modes
</source>

Qt/Events/Resize

2012-09-12T13:58:35Z

Daviddoria:

==main.cpp==
<source lang="cpp">
#include <QApplication>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Form form;

form.show();
return app.exec();
}

</source>

==form.h==
<source lang="cpp">
#ifndef FORM_H
#define FORM_H

#include "ui_form.h"

class QGraphicsPixmapItem;

class Form : public QWidget, public Ui::Form
{
Q_OBJECT

public:
Form(QWidget *parent = 0);
protected:

void resizeEvent ( QResizeEvent * event );

QGraphicsPixmapItem* BlackItem;
};

#endif
</source>

==form.cpp==
<source lang="cpp">
#include <QtGui>

#include <iostream>

#include "form.h"

Form::Form(QWidget *parent) : QWidget(parent)
{
this->setupUi(this);

QGraphicsScene* scene = new QGraphicsScene;

//// Add a qpixmap to the scene.
QPixmap pixmap(40, 40);
QColor black(0,0,0);
pixmap.fill(black);
this->BlackItem = scene->addPixmap(pixmap);
//this->graphicsView->fitInView(blackItem);

//Add another qpixmap to the scene. Drag one of them around and watch the scene change.
QPixmap pixmap2(30, 30);
QColor red(255,0,0);
pixmap2.fill(red);
QGraphicsPixmapItem * redItem = scene->addPixmap(pixmap2);
redItem->setFlag(QGraphicsItem::ItemIsMovable);

scene->setSceneRect(pixmap.rect());
this->graphicsView->setScene(scene);
}

void Form::resizeEvent ( QResizeEvent * event )
{
std::cout << "ResizeEvent" << std::endl;
this->graphicsView->fitInView(this->BlackItem);
}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>312</width>
<height>243</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<widget class="QGraphicsView" name="graphicsView">
<property name="backgroundBrush">
<brush brushstyle="NoBrush">
<color alpha="255">
<red>0</red>
<green>0</green>
<blue>0</blue>
</color>
</brush>
</property>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(ResizeEvent)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs form.ui)
QT4_WRAP_CPP(MOCSrcs form.h)

include_directories(${include_directories} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(ResizeEvent main.cpp form.h form.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(ResizeEvent ${QT_LIBRARIES})

</source>

CPP/Boost/Heap/IndirectCompare

2012-09-05T21:35:05Z

Daviddoria: Created page with '<syntaxhighlight lang="cpp"> #include <boost/heap/binomial_heap.hpp> #include <boost/pending/indirect_cmp.hpp> #include <boost/array.hpp> #include <boost/graph/grid_graph.hpp> #i…'

<syntaxhighlight lang="cpp">
#include <boost/heap/binomial_heap.hpp>
#include <boost/pending/indirect_cmp.hpp>
#include <boost/array.hpp>
#include <boost/graph/grid_graph.hpp>
#include <iostream>

int main(int, char*[])
{
boost::array<std::size_t, 2> lengths = { { 2,2 } };
typedef boost::grid_graph<2> GraphType;
GraphType graph(lengths);
typedef boost::graph_traits<GraphType>::vertex_descriptor Vertex;
typedef boost::property_map<GraphType, boost::vertex_index_t>::const_type GridIndexMapType;
GridIndexMapType gridIndexMap(get(boost::vertex_index, graph));

typedef boost::graph_traits<GraphType>::vertex_iterator VertexIteratorType;
VertexIteratorType vertexIterator, vertexIteratorEnd;

typedef boost::vector_property_map<float, GridIndexMapType> PriorityMapType;
PriorityMapType priorityMap(gridIndexMap);

typedef boost::indirect_cmp<PriorityMapType, std::less<float> > IndirectComparisonType;
IndirectComparisonType indirectComparison(priorityMap);

typedef boost::heap::binomial_heap<Vertex, boost::heap::stable<false>, boost::heap::compare<IndirectComparisonType> > PriorityQueueType;
PriorityQueueType pq(indirectComparison);

typedef typename PriorityQueueType::handle_type handle_t;

for( tie(vertexIterator, vertexIteratorEnd) = vertices(graph); vertexIterator != vertexIteratorEnd; ++vertexIterator)
{
put(priorityMap, *vertexIterator, rand() % 1000);
pq.push(*vertexIterator);
}

// Change all of the priorities in the map
for( tie(vertexIterator, vertexIteratorEnd) = vertices(graph); vertexIterator != vertexIteratorEnd; ++vertexIterator)
{
put(priorityMap, *vertexIterator, rand() % 1000);
}

// Resort the queue
for( tie(vertexIterator, vertexIteratorEnd) = vertices(graph); vertexIterator != vertexIteratorEnd; ++vertexIterator)
{
// pq.update(handle3, 5);
}

// Output the final queue
while(!pq.empty())
{
Vertex v = pq.top();
std::cout << v[0] << " " << v[1] << std::endl;
pq.pop();
}

return 0;
}

</syntaxhighlight>

CPP/Boost/BGL/IndirectPriorityQueue

2012-09-03T14:42:45Z

Daviddoria:

==IndirectPriorityQueue.cpp==
<source lang="cpp">
#include <iostream>
#include <iomanip>

#include <boost/graph/grid_graph.hpp>
#include <boost/graph/detail/d_ary_heap.hpp>
#include <boost/property_map/property_map.hpp>

#include <cstdlib>

template <typename TQueue>
static void OutputQueue(TQueue queue);

int main(int, char*[])
{
srand((unsigned int)time(NULL));

boost::array<std::size_t, 2> lengths = { { 5,5 } };
typedef boost::grid_graph<2> GraphType;
GraphType graph(lengths);
typedef boost::graph_traits<GraphType>::vertex_descriptor Vertex;
typedef boost::property_map<GraphType, boost::vertex_index_t>::const_type GridIndexMapType;
GridIndexMapType gridIndexMap(get(boost::vertex_index, graph));

typedef boost::vector_property_map<std::size_t, GridIndexMapType> IndexInHeapMap;
IndexInHeapMap index_in_heap(gridIndexMap);

typedef boost::graph_traits<GraphType>::vertex_iterator VertexIteratorType;

typedef boost::vector_property_map<float, GridIndexMapType> PriorityMapType;
PriorityMapType priorityMap(gridIndexMap);
VertexIteratorType vertexIterator, vertexIteratorEnd;

typedef std::greater<float> ComparisonFunctor;
typedef boost::d_ary_heap_indirect<Vertex, 4, IndexInHeapMap, PriorityMapType, ComparisonFunctor > MutableQueueType;

ComparisonFunctor comparisonFunctor;
MutableQueueType mutableQueue(priorityMap, index_in_heap, comparisonFunctor);

std::cout << "There are " << mutableQueue.size() << " items in the queue." << std::endl;

// Add random values to the vertices and add them to the queue
for( tie(vertexIterator, vertexIteratorEnd) = vertices(graph); vertexIterator != vertexIteratorEnd; ++vertexIterator)
{
put(priorityMap, *vertexIterator, rand() % 1000);
}

for( tie(vertexIterator, vertexIteratorEnd) = vertices(graph); vertexIterator != vertexIteratorEnd; ++vertexIterator)
{
mutableQueue.push(*vertexIterator);
}

std::cout << "There are " << mutableQueue.size() << " items in the queue." << std::endl;

std::cout << "The priority queue is: " << std::endl;
OutputQueue(mutableQueue);

// Insert another set of random values for each vertex
for( tie(vertexIterator, vertexIteratorEnd) = vertices(graph); vertexIterator != vertexIteratorEnd; ++vertexIterator)
{
put(priorityMap, *vertexIterator, rand() % 1000);
}

for( tie(vertexIterator, vertexIteratorEnd) = vertices(graph); vertexIterator != vertexIteratorEnd; ++vertexIterator)
{
mutableQueue.push(*vertexIterator);
}

std::cout << "There are " << mutableQueue.size() << " items in the queue." << std::endl;

std::cout << "The priority queue is: " << std::endl;
OutputQueue(mutableQueue);

std::cout << std::endl;

return 0;
}

template <typename TQueue>
static void OutputQueue(TQueue queue)
{
while( ! queue.empty() )
{
typename TQueue::value_type u = queue.top();

// These two lines are equivalent
std::cout << "vertex: " << u[0] << " " << u[1] << " priority: " << get(queue.keys(), u) << std::endl;

queue.pop();
}
}

/* Output:
There are 0 items in the queue.
There are 25 items in the queue.
The priority queue is:
vertex: 4 3 priority: 989
vertex: 3 2 priority: 976
vertex: 0 1 priority: 937
vertex: 1 4 priority: 824
vertex: 0 2 priority: 805
vertex: 1 0 priority: 770
vertex: 4 2 priority: 770
vertex: 4 4 priority: 733
vertex: 2 2 priority: 623
vertex: 0 4 priority: 566
vertex: 3 0 priority: 513
vertex: 4 0 priority: 494
vertex: 2 3 priority: 418
vertex: 3 1 priority: 411
vertex: 1 1 priority: 408
vertex: 0 3 priority: 378
vertex: 3 3 priority: 300
vertex: 3 4 priority: 286
vertex: 0 0 priority: 206
vertex: 2 1 priority: 198
vertex: 1 2 priority: 159
vertex: 2 0 priority: 157
vertex: 2 4 priority: 108
vertex: 1 3 priority: 103
vertex: 4 1 priority: 5
There are 50 items in the queue.
The priority queue is:
vertex: 3 0 priority: 998
vertex: 3 2 priority: 979
vertex: 3 2 priority: 979
vertex: 2 4 priority: 920
vertex: 0 1 priority: 853
vertex: 0 1 priority: 853
vertex: 3 0 priority: 998
vertex: 4 4 priority: 842
vertex: 2 2 priority: 830
vertex: 2 2 priority: 830
vertex: 3 3 priority: 811
vertex: 3 3 priority: 811
vertex: 0 2 priority: 781
vertex: 0 2 priority: 781
vertex: 1 1 priority: 556
vertex: 4 0 priority: 517
vertex: 4 0 priority: 517
vertex: 4 3 priority: 464
vertex: 4 3 priority: 464
vertex: 3 1 priority: 363
vertex: 3 1 priority: 363
vertex: 0 4 priority: 345
vertex: 1 1 priority: 556
vertex: 0 4 priority: 345
vertex: 1 2 priority: 300
vertex: 1 2 priority: 300
vertex: 4 4 priority: 842
vertex: 2 1 priority: 287
vertex: 2 1 priority: 287
vertex: 2 3 priority: 222
vertex: 2 3 priority: 222
vertex: 1 0 priority: 197
vertex: 2 4 priority: 920
vertex: 1 0 priority: 197
vertex: 1 4 priority: 189
vertex: 1 4 priority: 189
vertex: 0 3 priority: 187
vertex: 0 3 priority: 187
vertex: 1 3 priority: 136
vertex: 1 3 priority: 136
vertex: 0 0 priority: 119
vertex: 0 0 priority: 119
vertex: 2 0 priority: 118
vertex: 2 0 priority: 118
vertex: 3 4 priority: 115
vertex: 3 4 priority: 115
vertex: 4 1 priority: 70
vertex: 4 1 priority: 70
vertex: 4 2 priority: 63
vertex: 4 2 priority: 63

*/

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(IndirectPriorityQueue)

set(Boost_USE_MULTITHREADED ON)
FIND_PACKAGE(Boost 1.38 COMPONENTS)

INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${Boost_INCLUDE_DIRS})
LINK_DIRECTORIES(${LINK_DIRECTORIES} ${Boost_LIBRARY_DIRS})

ADD_EXECUTABLE(IndirectPriorityQueue IndirectPriorityQueue.cpp)

</source>

CPP/C++0x/Lambda

2012-07-13T17:39:50Z

Daviddoria:

==Lambda.cpp==
<source lang="cpp">
#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>

void Lambda();

void Equivalent();

int main()
{

}

void Lambda()
{
std::vector<std::pair<int, float> > v{
{1, 4.5}, {3, 6.7}, {9, 7.8}
};

auto it=std::find_if(v.begin(), v.end(), [](std::pair<int, float> p) {
return p.first==3;
}); // This lambda expression (or "anonymous function") lets you "on the fly" define a function to be used.
// Here, we are comparing the .first of all of the items in the container to "3"
std::cout << it->second;
}

struct Equals
{
Equals(const int value)
{
CompareValue = value;
}

bool operator()(const std::pair<int, float>& value)
{
return value.first == 3;
}

int CompareValue;
};

void Equivalent()
{
std::vector<std::pair<int, float> > v{
{1, 4.5}, {3, 6.7}, {9, 7.8}
};

// This works, but this following is shorter:
// Equals myEquals;
// myEquals.CompareValue = 3;
// auto it=std::find_if(v.begin(), v.end(), myEquals);

auto it=std::find_if(v.begin(), v.end(), Equals(3));

std::cout << it->second;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(Lambda)
ADD_EXECUTABLE(Lambda Lambda.cpp)

</source>

CPP/STL/Set/BoundedInsert

2012-07-13T14:47:42Z

Daviddoria: Created page with '==BoundedInsert.cpp== <source lang="cpp"> #include <set> #include <iterator> #include <iostream> #include <algorithm> template<typename T> std::set<T>& bounded_insert(std::set<…'

==BoundedInsert.cpp==
<source lang="cpp">
#include <set>
#include <iterator>
#include <iostream>
#include <algorithm>

template<typename T>
std::set<T>& bounded_insert(std::set<T>& s, std::size_t max, T val) {
s.insert(val);
while(s.size() > max)
s.erase(std::max_element(s.begin(), s.end()));
return s;
}

int main() {
std::set<int> s;
bounded_insert(s, 10, 0);
bounded_insert(s, 10, 1);
bounded_insert(s, 10, 3);
bounded_insert(s, 10, 4);
bounded_insert(s, 10, 5);
bounded_insert(s, 10, 6);
bounded_insert(s, 10, 7);
bounded_insert(s, 10, 8);
bounded_insert(s, 10, 9);
bounded_insert(s, 10, 10);
bounded_insert(s, 10, 2);
bounded_insert(s, 10, 20);
std::copy(s.begin(), s.end(), std::ostream_iterator<int>(std::cout, " "));
}
</source>

== CMakeLists.txt ==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(BoundedInsert)

ADD_EXECUTABLE(BoundedInsert BoundedInsert.cpp)

</source>

Qt/Utilities/EventFilter

2012-07-06T20:40:39Z

Daviddoria:

==main.cpp==
<source lang="cpp">
#include <QProgressDialog>
#include <QApplication>

#include "form.h"

int main( int argc, char **argv )
{
QApplication app(argc, argv);
MainWindow window;

window.show();

return app.exec();
}

</source>

==form.h==
<source lang="cpp">

#ifndef FORM_H
#define FORM_H

#include "ui_main.h"

#include <QTime>

class MainWindow : public QMainWindow, public Ui::MainWindow
{
Q_OBJECT

public:
MainWindow();
bool eventFilter(QObject *object, QEvent *event);
};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include "form.h"

// Qt
#include <QtGui>
#include <QEvent>

// STL
#include <iostream>

MainWindow::MainWindow()
{
setupUi(this);
lineEdit->installEventFilter(this);
}

bool MainWindow::eventFilter(QObject *object, QEvent *event)
{
if (object == lineEdit && event->type() == QEvent::FocusOut)
{
std::cout << "eventFilter" << std::endl;
}
return false; // Pass the event along (don't consume it)
}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>571</width>
<height>500</height>
</rect>
</property>
<property name="windowTitle">
<string>MainWindow</string>
</property>
<widget class="QWidget" name="centralwidget">
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QLineEdit" name="lineEdit"/>
</item>
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
</layout>
</widget>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(EventFilter)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs main.ui)
QT4_WRAP_CPP(MOCSrcs form.h)

include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(EventFilter main.cpp form.cpp ${UISrcs} ${MOCSrcs})
TARGET_LINK_LIBRARIES(EventFilter ${QT_LIBRARIES})

</source>

CPP/Pragma

2012-06-10T13:04:37Z

Daviddoria: Created page with '==Pragma.cpp== <source lang="cpp"> #include <iostream> #include <typeinfo> #define STR(x) STR2(x) #define STR2(x) #x #define FOO 3 int main(int, char*[]) { #pragma message("…'

==Pragma.cpp==
<source lang="cpp">
#include <iostream>
#include <typeinfo>

#define STR(x) STR2(x)
#define STR2(x) #x

#define FOO 3

int main(int, char*[])
{
#pragma message("A message!")

#pragma message(STR(FOO))

return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(Pragma)

ADD_EXECUTABLE(Pragma Pragma.cpp)
</source>

Qt/AutoConnect

2012-06-06T00:46:43Z

Daviddoria: Created page with '==AutoConnect.cpp== <source lang="cpp"> #include <QApplication> #include "form.h" int main(int argc, char *argv[]) { QApplication app(argc, argv); Form form; form.show…'

==AutoConnect.cpp==
<source lang="cpp">
#include <QApplication>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Form form;

form.show();
return app.exec();
}

</source>

==form.h==
<source lang="cpp">
#ifndef FORM_H
#define FORM_H

#include "ui_form.h"

class Form : public QWidget, private Ui::Form
{
Q_OBJECT

public:
Form(QWidget *parent = 0);

public slots:
void on_pushButton_clicked();

};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include <QtGui>

#include "form.h"

Form::Form(QWidget *parent)
: QWidget(parent)
{
setupUi(this);
}

void Form::on_pushButton_clicked()
{
this->label->setText(this->textEdit->document()->toPlainText());
}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<widget class="QPushButton" name="pushButton">
<property name="geometry">
<rect>
<x>80</x>
<y>120</y>
<width>91</width>
<height>28</height>
</rect>
</property>
<property name="text">
<string>PushButton</string>
</property>
</widget>
<widget class="QLabel" name="label">
<property name="geometry">
<rect>
<x>170</x>
<y>220</y>
<width>61</width>
<height>18</height>
</rect>
</property>
<property name="text">
<string>TextLabel</string>
</property>
</widget>
<widget class="QTextEdit" name="textEdit">
<property name="geometry">
<rect>
<x>250</x>
<y>30</y>
<width>104</width>
<height>78</height>
</rect>
</property>
</widget>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(AutoConnect)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs form.ui)
QT4_WRAP_CPP(MOCSrcs form.h)

include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(AutoConnect AutoConnect.cpp form.h form.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(AutoConnect ${QT_LIBRARIES})

</source>

CPP/Eigen/STL vector of Eigen vectors

2012-05-17T16:13:10Z

Daviddoria: Created page with '==STLVector.cpp== <source lang="cpp"> #include <iostream> #include <vector> #include <Eigen/Geometry> #include <Eigen/Dense> // for Vector #include <Eigen/StdVector> // Required…'

==STLVector.cpp==
<source lang="cpp">
#include <iostream>
#include <vector>

#include <Eigen/Geometry>
#include <Eigen/Dense> // for Vector
#include <Eigen/StdVector> // Required (http://eigen.tuxfamily.org/dox-devel/TopicStlContainers.html)

// If Eigen complains about "ptrdiff_t does not name a type", #include <cstddef> from the file it is complaining about.

typedef std::vector<Eigen::Vector2d,Eigen::aligned_allocator<Eigen::Vector2d> > Point2DVector;

Point2DVector Generate2DPoints();

int main(int argc, char *argv[])
{
return 0;
}

Point2DVector Generate2DPoints()
{
Point2DVector points;

float x,y;

x=282;y=274;
points.push_back(Eigen::Vector2d(x,y));

x=397;y=227;
points.push_back(Eigen::Vector2d(x,y));

x=577;y=271;
points.push_back(Eigen::Vector2d(x,y));

x=462;y=318;
points.push_back(Eigen::Vector2d(x,y));

x=270;y=479;
points.push_back(Eigen::Vector2d(x,y));

x=450;y=523;
points.push_back(Eigen::Vector2d(x,y));

x=566;y=475;
points.push_back(Eigen::Vector2d(x,y));

return points;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(STLVector)
include_directories(/media/portable/src/Eigen)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DEIGEN_YES_I_KNOW_SPARSE_MODULE_IS_NOT_STABLE_YET")
ADD_EXECUTABLE(STLVector STLVector.cpp )

</source>

CPP/Boost/BGL/MaxFlow

2012-05-03T21:01:46Z

Daviddoria: Created page with '==MaxFlow.cpp== <source lang="cpp"> #include <iostream> #include <boost/graph/adjacency_list.hpp> #include <boost/graph/boykov_kolmogorov_max_flow.hpp> #include <boost/graph/push…'

==MaxFlow.cpp==
<source lang="cpp">
#include <iostream>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/boykov_kolmogorov_max_flow.hpp>
#include <boost/graph/push_relabel_max_flow.hpp>
#include <boost/graph/edmonds_karp_max_flow.hpp>

using namespace boost;

typedef int EdgeWeightType;

typedef adjacency_list_traits < vecS, vecS, directedS > Traits;
typedef adjacency_list < vecS, vecS, directedS,
property < vertex_name_t, std::string,
property < vertex_index_t, long,
property < vertex_color_t, boost::default_color_type,
property < vertex_distance_t, long,
property < vertex_predecessor_t, Traits::edge_descriptor > > > > >,

property < edge_capacity_t, EdgeWeightType,
property < edge_residual_capacity_t, EdgeWeightType,
property < edge_reverse_t, Traits::edge_descriptor > > > > Graph;

Traits::edge_descriptor AddEdge(Traits::vertex_descriptor &v1,
Traits::vertex_descriptor &v2,
property_map < Graph, edge_reverse_t >::type &rev,
const double capacity,
Graph &g);

int main(int, char*[])
{
Graph g; //a graph with 0 vertices

property_map < Graph, edge_reverse_t >::type rev = get(edge_reverse, g);

//add a source and sink node, and store them in s and t, respectively
Traits::vertex_descriptor v0 = add_vertex(g);
Traits::vertex_descriptor v1 = add_vertex(g);
Traits::vertex_descriptor v2 = add_vertex(g);
Traits::vertex_descriptor v3 = add_vertex(g);

/*
AddEdge(v0, v1, rev, 6.0, g);
AddEdge(v0, v2, rev, 5.0, g);
AddEdge(v1, v2, rev, 8.0, g);
AddEdge(v2, v3, rev, 7.0, g);
*/
AddEdge(v0, v1, rev, 6, g);
AddEdge(v0, v2, rev, 5, g);
AddEdge(v1, v3, rev, 8, g);
AddEdge(v2, v3, rev, 7, g);

//find min cut
EdgeWeightType flow = boykov_kolmogorov_max_flow(g, v0, v3); // a list of sources will be returned in s, and a list of sinks will be returned in t
//EdgeWeightType flow = push_relabel_max_flow(g, v0, v3); // a list of sources will be returned in s, and a list of sinks will be returned in t
//EdgeWeightType flow = edmunds_karp_max_flow(g, v0, v3); // a list of sources will be returned in s, and a list of sinks will be returned in t

std::cout << "Max flow is: " << flow << std::endl;

property_map<Graph, edge_capacity_t>::type
capacity = get(edge_capacity, g);
property_map<Graph, edge_residual_capacity_t>::type
residual_capacity = get(edge_residual_capacity, g);

graph_traits<Graph>::vertex_iterator u_iter, u_end;
graph_traits<Graph>::out_edge_iterator ei, e_end;
for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
if (capacity[*ei] > 0)
std::cout << "Source: " << *u_iter << " destination: " << target(*ei, g) << " capacity: " << capacity[*ei] << "residual cap: " << residual_capacity[*ei] << " used capacity: "
<< (capacity[*ei] - residual_capacity[*ei]) << std::endl;

return 0;
}

Traits::edge_descriptor AddEdge(Traits::vertex_descriptor &v1, Traits::vertex_descriptor &v2, property_map < Graph, edge_reverse_t >::type &rev, const double capacity, Graph &g)
{
Traits::edge_descriptor e1 = add_edge(v1, v2, g).first;
Traits::edge_descriptor e2 = add_edge(v2, v1, g).first;
put(edge_capacity, g, e1, capacity);
put(edge_capacity, g, e2, capacity);

rev[e1] = e2;
rev[e2] = e1;
}

/*
//find min cut
kolmogorov_max_flow
(Graph& g,
CapacityEdgeMap cap,
ResidualCapacityEdgeMap res_cap,
ReverseEdgeMap rev,
ColorMap color,
IndexMap idx,
typename graph_traits<Graph>::vertex_descriptor src,
typename graph_traits<Graph>::vertex_descriptor sink)
{
*/

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

project(MaxFlow)

set(Boost_USE_MULTITHREADED ON) # which is the default
find_package(Boost 1.46)

include_directories(${Boost_INCLUDE_DIRS})

add_executable(MaxFlow MaxFlow.cpp)

</source>

PCL

2012-02-03T00:44:48Z

Daviddoria: Created page with 'Examples to be added to PCL: '''Misc:''' * Nearest neighbors * Region growing '''Features:''' * RIFT feature * CVFH feature * PPF feature * Integral image usage * Spin image * …'

Examples to be added to PCL:

'''Misc:'''
* Nearest neighbors
* Region growing

'''Features:'''
* RIFT feature
* CVFH feature
* PPF feature
* Integral image usage
* Spin image
* Radius based surface descriptor

'''Keypoints:'''
* Harris Keypoint
* SIFT Keypoint
* Smoothed surface Keypoint

'''Registration:'''
* How to use GICP
* Registration pipeline with code snippets for finding Keypoints, Features, Correspondences and so on (Can be a part of Applications)

'''Applications:'''
* Object recognition pipeline from scene cloud to object cloud
* Localization based on registration using RGB-D map
* Object tracking
* Filtering the cloud based on color

CPP/Boost/BGL/FilteredGraphEdges

2012-01-26T15:25:23Z

Daviddoria: Created page with '==FilteredGraph.cpp== <source lang="cpp"> #include <iostream> #include <boost/graph/adjacency_list.hpp> #include <boost/array.hpp> #include <boost/graph/filtered_graph.hpp> #inc…'

==FilteredGraph.cpp==
<source lang="cpp">
#include <iostream>

#include <boost/graph/adjacency_list.hpp>
#include <boost/array.hpp>
#include <boost/graph/filtered_graph.hpp>
#include <boost/graph/graph_utility.hpp>

template <typename EdgeWeightMap>
struct positive_edge_weight {
positive_edge_weight() { }
positive_edge_weight(EdgeWeightMap weight) : m_weight(weight) { }
template <typename Edge>
bool operator()(const Edge& e) const {
return 0 < get(m_weight, e);
}
EdgeWeightMap m_weight;
};

int main()
{
using namespace boost;

typedef adjacency_list<vecS, vecS, directedS,
no_property, property<edge_weight_t, int> > Graph;
typedef property_map<Graph, edge_weight_t>::type EdgeWeightMap;

enum { A, B, C, D, E, N };
const char* name = "ABCDE";
Graph g(N);
add_edge(A, B, 2, g);
add_edge(A, C, 0, g);
add_edge(C, D, 1, g);
add_edge(C, E, 0, g);
add_edge(D, B, 3, g);
add_edge(E, C, 0, g);

positive_edge_weight<EdgeWeightMap> filter(get(edge_weight, g));
filtered_graph<Graph, positive_edge_weight<EdgeWeightMap> > filteredGraph(g, filter);

boost::print_graph(filteredGraph, name);
return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(FilteredGraphEdges)

set(Boost_USE_MULTITHREADED ON)
FIND_PACKAGE(Boost 1.38 COMPONENTS required)

INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${Boost_INCLUDE_DIRS})
LINK_DIRECTORIES(${LINK_DIRECTORIES} ${Boost_LIBRARY_DIRS})

ADD_EXECUTABLE(FilteredGraphEdges FilteredGraphEdges.cpp)

</source>

CPP/Boost/BGL/GridGraphVertexIterator

2012-01-25T21:01:13Z

Daviddoria: Created page with '==GridGraphVertexIterator.cpp== <source lang="cpp"> #include <iostream> #include <boost/array.hpp> #include <boost/graph/grid_graph.hpp> int main(int argc, char* argv[]) { ty…'

==GridGraphVertexIterator.cpp==
<source lang="cpp">
#include <iostream>
#include <boost/array.hpp>
#include <boost/graph/grid_graph.hpp>

int main(int argc, char* argv[])
{
typedef boost::grid_graph<2> Graph;

boost::array<std::size_t, 2> lengths = { { 5,5 } };
Graph graph(lengths);
boost::graph_traits<Graph>::vertex_iterator iterator = vertices(graph); // Compiler error - can't convert iterator to this iterator type
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(GridGraphVertexIterator)

set(Boost_USE_MULTITHREADED ON)
FIND_PACKAGE(Boost 1.38 COMPONENTS)

INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${Boost_INCLUDE_DIRS})
LINK_DIRECTORIES(${LINK_DIRECTORIES} ${Boost_LIBRARY_DIRS})

ADD_EXECUTABLE(GridGraphVertexIterator GridGraphVertexIterator.cpp)

</source>

CPP/Boost/BGL/d ary heap indirect

2012-01-25T19:19:30Z

Mikael.s.persson: /* d_ary_heap_indirect.cpp */

==d_ary_heap_indirect.cpp==
<source lang="cpp">
#include <iostream>
#include <iomanip>

#include <boost/graph/grid_graph.hpp>
#include <boost/graph/detail/d_ary_heap.hpp>
#include <boost/property_map/property_map.hpp>

#include <cstdlib>

template <typename T>
struct LessThanFunctor
{
bool operator()(const T& a, const T& b)
{
return a < b;
}
};

int main(int argc, char*argv[])
{
srand((unsigned int)time(NULL));

boost::array<std::size_t, 2> lengths = { { 5,5 } };
typedef boost::grid_graph<2> GraphType;
GraphType graph(lengths);
typedef boost::graph_traits<GraphType>::vertex_descriptor Vertex;
typedef boost::property_map<GraphType, boost::vertex_index_t>::const_type GridIndexMapType;
GridIndexMapType gridIndexMap(get(boost::vertex_index, graph));

typedef boost::vector_property_map<std::size_t, GridIndexMapType> IndexInHeapMap;
IndexInHeapMap index_in_heap(gridIndexMap);

boost::graph_traits<GraphType>::vertex_iterator ui, ui_end;
for( tie(ui,ui_end) = vertices(graph); ui != ui_end; ++ui)
put(index_in_heap, *ui, static_cast<std::size_t>(-1));

typedef boost::vector_property_map<float, GridIndexMapType> PriorityMapType;
PriorityMapType priorityMap(gridIndexMap);
for( tie(ui,ui_end) = vertices(graph); ui != ui_end; ++ui)
put(priorityMap, *ui, rand() % 1000);

std::cout << "Given the following random grid-graph: " << std::endl;
Vertex v = vertex(0,graph);
for(std::size_t i = 0; i < lengths[0]; ++i) {
Vertex u = v;
for(std::size_t j = 0; j < lengths[1]; ++j) {
std::cout << std::setw(5) << get(priorityMap, u);
u = graph.next(u,1);
};
v = graph.next(v,0);
std::cout << std::endl;
};

typedef boost::d_ary_heap_indirect<Vertex, 4, IndexInHeapMap, PriorityMapType, LessThanFunctor<float> > MutableQueue;

LessThanFunctor<float> lessThanFunctor;
MutableQueue mutableQueue(priorityMap, index_in_heap, lessThanFunctor);

for( tie(ui,ui_end) = vertices(graph); ui != ui_end; ++ui)
mutableQueue.push(*ui);

std::cout << "We get the following priority queue: " << std::endl;
while( ! mutableQueue.empty() ) {
Vertex u = mutableQueue.top(); mutableQueue.pop();
std::cout << std::setw(5) << get(priorityMap, u);
};
std::cout << std::endl;
return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(d_ary_heap_indirect)

set(Boost_USE_MULTITHREADED ON)
FIND_PACKAGE(Boost 1.38 COMPONENTS)

INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${Boost_INCLUDE_DIRS})
LINK_DIRECTORIES(${LINK_DIRECTORIES} ${Boost_LIBRARY_DIRS})

ADD_EXECUTABLE(d_ary_heap_indirect d_ary_heap_indirect.cpp)

</source>

CPP/Boost/BGL/GridGraphProperties

2012-01-23T20:03:24Z

Daviddoria: Created page with 'Grid graphs must use "exterior properties". Here is how: ==GridGraphProperties.cpp== <source lang="cpp"> #include <iostream> #include <boost/array.hpp> #include <boost/graph/gri…'

Grid graphs must use "exterior properties". Here is how:

==GridGraphProperties.cpp==
<source lang="cpp">
#include <iostream>
#include <boost/array.hpp>
#include <boost/graph/grid_graph.hpp>

int main(int argc, char* argv[])
{
typedef boost::grid_graph<2> GraphType;

const unsigned int dimension = 5;
boost::array<std::size_t, 2> lengths = { { dimension, dimension } };
GraphType graph(lengths);

boost::graph_traits<GraphType>::vertex_descriptor v = { { 0, 1 } };

std::vector<float> vertexData(dimension * dimension, 3);

typedef boost::property_map<GraphType, boost::vertex_index_t>::const_type indexMapType;

indexMapType indexMap(get(boost::vertex_index, graph));

boost::iterator_property_map<std::vector<float>::iterator, indexMapType> myMap(vertexData.begin(), indexMap);

float retrieved = get(myMap, v);
std::cout << "Retrieved: " << retrieved << std::endl;

return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(GridGraphProperties)

set(Boost_USE_MULTITHREADED ON)
FIND_PACKAGE(Boost 1.38 COMPONENTS required)

INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${Boost_INCLUDE_DIRS})
LINK_DIRECTORIES(${LINK_DIRECTORIES} ${Boost_LIBRARY_DIRS})

ADD_EXECUTABLE(GridGraphProperties GridGraphProperties.cpp)

</source>

CPP/Boost/BGL/FilteredGraph

2012-01-22T21:55:53Z

Daviddoria: Get a vertex_iterator

==FilteredGraph.cpp==
<source lang="cpp">
#include <iostream>

#include <boost/graph/adjacency_list.hpp>
#include <boost/array.hpp>
#include <boost/graph/filtered_graph.hpp>
#include <boost/graph/graph_utility.hpp>

template <typename TGraph>
struct vertex_id_filter
{
bool operator()(const typename boost::graph_traits<TGraph>::vertex_descriptor& v) const
{
return 3 < v; // keep all vertx_descriptors greater than 3
}
};

int main()
{

typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS,
boost::no_property, boost::property<boost::edge_weight_t, int> > Graph;
typedef boost::property_map<Graph, boost::edge_weight_t>::type EdgeWeightMap;

unsigned int numberOfVertices = 10;
Graph g(numberOfVertices);
for(unsigned int i = 0; i < numberOfVertices - 1; ++i)
{
add_edge(i, i+1, g);
}

std::cout << "Original graph:" << std::endl;
boost::print_graph(g);

vertex_id_filter<Graph> filter;
typedef boost::filtered_graph<Graph, boost::keep_all, vertex_id_filter<Graph> > FilteredGraphType;
FilteredGraphType filteredGraph(g, boost::keep_all(), filter); // (graph, EdgePredicate, VertexPredicate)

std::cout << "Filtered graph:" << std::endl;
boost::print_graph(filteredGraph);

FilteredGraphType::vertex_iterator ui,ui_end; tie(ui,ui_end) = vertices(filteredGraph);

return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(FilteredGraphVertices)

set(Boost_USE_MULTITHREADED ON)
FIND_PACKAGE(Boost 1.38 COMPONENTS required)

INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${Boost_INCLUDE_DIRS})
LINK_DIRECTORIES(${LINK_DIRECTORIES} ${Boost_LIBRARY_DIRS})

ADD_EXECUTABLE(FilteredGraphVertices FilteredGraphVertices.cpp)

</source>

CPP/CustomIterator

2012-01-02T16:19:32Z

Daviddoria: Created page with 'This example demonstrates what you have to implement to create an STL iterator. ==CustomIterator.cpp== <source lang="cpp"> #include <iterator> template <typename T> struct Poin…'

This example demonstrates what you have to implement to create an STL iterator.

==CustomIterator.cpp==
<source lang="cpp">
#include <iterator>

template <typename T>
struct PointedType;

template <typename T>
struct PointedType<T*>
{
typedef T value_type;
};

using namespace std;

template <typename InputIterator>
struct DerefIterator
{
typedef input_iterator_tag iterator_category;
typedef typename PointedType<
typename iterator_traits<InputIterator>::value_type>::value_type
value_type;
typedef typename iterator_traits<InputIterator>::difference_type
difference_type;
typedef value_type* pointer;
typedef value_type& reference;

public:
explicit DerefIterator(const InputIterator& ii)
: it(ii) {}

// Returns the object pointed by the object referenced by it
reference operator*() const { return **it; }
pointer operator->() const { return *it; }

DerefIterator& operator++()
{
++it;
return *this;
}

DerefIterator operator++(int)
{
DerefIterator tmp = *this;
++it;
return tmp;
}

bool equals(const DerefIterator<InputIterator> & di) const
{
return di.it == it;
}

private:
InputIterator it;
};

// Equality functions

template <typename InputIterator>
inline bool operator==(const DerefIterator<InputIterator>& di1,
const DerefIterator<InputIterator>& di2)
{
return di1.equals(di2);
}

template <typename InputIterator>
inline bool operator!=(const DerefIterator<InputIterator>& di1,
const DerefIterator<InputIterator>& di2)
{
return ! (di1 == di2);
}

//Helper function

template <typename InputIterator>
DerefIterator<InputIterator> deref_iterator(const InputIterator& ii)
{
return DerefIterator<InputIterator>(ii);
}

int main()
{
return 0;
};
</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(CustomIterator)

ADD_EXECUTABLE(CustomIterator CustomIterator.cpp)
</source>

CPP/Boost/Iterators/IndirectIterator

2012-01-02T16:17:43Z

Daviddoria: Created page with '==IndirectIterator.cpp== <source lang="cpp"> #include <iostream> #include <set> #include <boost/iterator/indirect_iterator.hpp> // Expose the itererator if the container stores…'

==IndirectIterator.cpp==
<source lang="cpp">
#include <iostream>
#include <set>

#include <boost/iterator/indirect_iterator.hpp>

// Expose the itererator if the container stores objects.
// class MyCollection
// {
// public:
// // Iterator interface
// typedef std::set<int>::iterator iterator;
// typedef std::set<int>::const_iterator const_iterator;
//
// iterator begin() { return objects.begin(); }
//
// iterator end() { return objects.end(); }
//
// private:
//
// std::set<int> objects;
// };

// Expose the itererator if the container stores pointers.
class MyCollection
{
public:
MyCollection()
{
objects.insert(new int(3));
}
// Iterator interface
//typedef boost::indirect_iterator<std::set<int> > iterator;
typedef boost::indirect_iterator<std::set<int*>::iterator> iterator;

iterator begin() { return objects.begin(); }

iterator end() { return objects.end(); }

private:

std::set<int*> objects;
};

int main()
{
MyCollection myCollection;

for(MyCollection::iterator iterator = myCollection.begin(); iterator != myCollection.end(); iterator++)
{
std::cout << " " << *iterator;
}
return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">

cmake_minimum_required(VERSION 2.6)

Project(IndirectIterator)

ADD_EXECUTABLE(IndirectIterator IndirectIterator.cpp)
</source>

CPP/StaticConstInitialization

2011-12-29T14:33:26Z

Daviddoria: Created page with '==main.cpp== <source lang="cpp"> #include <iostream> #include "StaticConst.h" int main(int argc, char* argv[]) { std::cout << MyClass::float_sqrteps << std::endl; return 0;…'

==main.cpp==
<source lang="cpp">
#include <iostream>

#include "StaticConst.h"

int main(int argc, char* argv[])
{
std::cout << MyClass::float_sqrteps << std::endl;
return 0;
}

</source>

==StaticConst.h==
<source lang="cpp">
#ifndef STATIC_CONST_H
#define STATIC_CONST_H

class MyClass
{
public:
// static const float float_sqrteps = 3.4526698307e-4f; // this is not ok
static const float float_sqrteps;
};

#endif

</source>

==StaticConst.cpp==
<source lang="cpp">
#include "StaticConst.h"

const float MyClass::float_sqrteps = 3.4526698307e-4f;

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(StaticConst)

ADD_EXECUTABLE(StaticConst main.cpp StaticConst.cpp)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -std=gnu++0x")
</source>

Broken/Qt/ModelView/AbstractTableModelCheckable

2011-12-28T19:13:17Z

Daviddoria: Needed to return something for the CheckStateRole in data()

==main.cpp==
<source lang="cpp">
#include <QApplication>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Form form;

form.show();
return app.exec();
}

</source>

==MyTableModel.h==
<source lang="cpp">
#ifndef MyTableModel_H
#define MyTableModel_H

#include <QAbstractTableModel>

#include <vector>

class Item
{
public:
Item(const float v, const Qt::CheckState s) {value = v; state = s;}
float value;
Qt::CheckState state;
};

class MyTableModel : public QAbstractTableModel
{
public:
MyTableModel();

int rowCount(const QModelIndex& parent) const;
int columnCount(const QModelIndex& parent) const;
QVariant data(const QModelIndex& index, int role) const;
QVariant headerData(int section, Qt::Orientation orientation, int role) const;
Qt::ItemFlags flags(const QModelIndex& index) const;
bool setData(const QModelIndex & index, const QVariant & value, int role);

protected:
std::vector<std::vector<Item> > Columns;
};

#endif

</source>

==MyTableModel.cpp==
<source lang="cpp">
#include "MyTableModel.h"

#include <sstream>

MyTableModel::MyTableModel() : QAbstractTableModel()
{
std::vector<Item> column1;
Item item(10, Qt::Checked);
column1.push_back(item);
item.value = 20; item.state = Qt::Checked;
column1.push_back(item);
item.value = 30; item.state = Qt::Checked;
column1.push_back(item);
item.value = 40; item.state = Qt::Checked;
column1.push_back(item);

Columns.push_back(column1);

std::vector<Item> column2;
item.value = 50; item.state = Qt::Unchecked;
column2.push_back(item);
item.value = 60; item.state = Qt::Unchecked;
column2.push_back(item);
item.value = 70; item.state = Qt::Unchecked;
column2.push_back(item);
item.value = 80; item.state = Qt::Unchecked;
column2.push_back(item);

Columns.push_back(column2);
}

int MyTableModel::rowCount(const QModelIndex& parent) const
{
return Columns[0].size();
}

int MyTableModel::columnCount(const QModelIndex& parent) const
{
return Columns.size();
}

QVariant MyTableModel::data(const QModelIndex& index, int role) const
{
if(role == Qt::DisplayRole)
{
return Columns[index.column()][index.row()].value;
}
if (index.column() == 1 && role == Qt::CheckStateRole)
{
return this->Columns[index.column()][index.row()].state;
}
return QVariant::Invalid;
}

QVariant MyTableModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if(role == Qt::DisplayRole)
{
std::stringstream ss;
if(orientation == Qt::Horizontal)
{
ss << "H_" << section;
return QString(ss.str().c_str());
}
else if(orientation == Qt::Vertical)
{
ss << "V_" << section;
return QString(ss.str().c_str());
}
}

return QVariant::Invalid;
}

bool MyTableModel::setData(const QModelIndex & index, const QVariant & value, int role)
{
if (index.column() == 1 && role == Qt::CheckStateRole)
{
this->Columns[index.column()][index.row()].state = static_cast<Qt::CheckState>(value.toUInt());
}

emit dataChanged(index, index);
return true;
}

Qt::ItemFlags MyTableModel::flags(const QModelIndex& index) const
{
Qt::ItemFlags returnFlags = QAbstractTableModel::flags(index);

if (index.column() == 1)
{
returnFlags |= Qt::ItemIsUserCheckable;
}

return returnFlags;
}

</source>

==form.h==
<source lang="cpp">
#ifndef FORM_H
#define FORM_H

#include "ui_form.h"

#include "MyTableModel.h"

class Form : public QWidget, public Ui::Form
{
Q_OBJECT

public:
Form(QWidget *parent = 0);

protected:
MyTableModel* model;
};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include <QAbstractTableModel>
#include <QtGui>

#include <iostream>
#include <sstream>

#include "form.h"

Form::Form(QWidget *parent) : QWidget(parent)
{
setupUi(this);

this->model = new MyTableModel;
this->tableView->setModel(model);

this->tableView->resizeColumnsToContents();
}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<widget class="QTableView" name="tableView">
<attribute name="horizontalHeaderStretchLastSection">
<bool>true</bool>
</attribute>
</widget>
</item>
<item row="1" column="0">
<widget class="QPushButton" name="btnUpdate">
<property name="text">
<string>Update</string>
</property>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(AbstractTableModelCheckable)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs form.ui)
QT4_WRAP_CPP(MOCSrcs form.h)

include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(AbstractTableModelCheckable main.cpp MyTableModel.cpp form.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(AbstractTableModelCheckable ${QT_LIBRARIES})

</source>

Qt/ModelView/ItemSelectionModel

2011-12-21T21:02:59Z

Daviddoria: Created page with '==main.cpp== <source lang="cpp"> #include <QApplication> #include "form.h" int main(int argc, char *argv[]) { QApplication app(argc, argv); Form form; form.show(); r…'

==main.cpp==
<source lang="cpp">
#include <QApplication>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Form form;

form.show();
return app.exec();
}

</source>

==form.h==
<source lang="cpp">
#ifndef FORM_H
#define FORM_H

#include "ui_form.h"

#include <QMainWindow>

class QStringList;
class QStringListModel;
class QItemSelectionModel;

class Form : public QMainWindow, private Ui::MainWindow
{
Q_OBJECT

public:
Form(QWidget *parent = 0);

public slots:
void slot_selectionChanged (const QItemSelection &selected, const QItemSelection &deselected );

protected:
QStringListModel* Model;
QItemSelectionModel* SelectionModel;
QStringList* StringList;
};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include <QtGui>

#include <iostream>

#include "form.h"

#include <QItemSelectionModel>
#include <QStringListModel>

Form::Form(QWidget *parent) : QMainWindow(parent)
{
setupUi(this);
std::cout << "Current path: " << QDir::currentPath().toStdString() << std::endl;

//this->StringList = new QStringList("a" << "b" << "c");
//this->StringList = new QStringList("a", "b", "c");
this->StringList = new QStringList;
*(this->StringList) << "a";
*(this->StringList) << "b";
*(this->StringList) << "c";

this->Model = new QStringListModel;
this->Model->setStringList(*this->StringList);
this->listView->setModel(this->Model);

this->SelectionModel = new QItemSelectionModel(this->Model);
this->listView->setSelectionModel(this->SelectionModel);

connect(this->SelectionModel, SIGNAL(selectionChanged (const QItemSelection&, const QItemSelection&)),
this, SLOT(slot_selectionChanged(QItemSelection,QItemSelection)));
}

void Form::slot_selectionChanged (const QItemSelection &selected, const QItemSelection &deselected )
{
for(unsigned int i = 0; i < selected.indexes().size(); ++i)
{
std::cout << selected.at(i).topLeft().row() << " ";
}
std::cout << std::endl;
}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>202</width>
<height>248</height>
</rect>
</property>
<property name="windowTitle">
<string>MainWindow</string>
</property>
<widget class="QWidget" name="centralwidget">
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QListView" name="listView"/>
</item>
</layout>
</widget>
<widget class="QMenuBar" name="menubar">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>202</width>
<height>20</height>
</rect>
</property>
<widget class="QMenu" name="menuFile">
<property name="title">
<string>File</string>
</property>
<addaction name="actionSave"/>
</widget>
<addaction name="menuFile"/>
</widget>
<widget class="QStatusBar" name="statusBar"/>
<action name="actionSave">
<property name="text">
<string>Save</string>
</property>
</action>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(ItemSelectionModel)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(ItemSelectionModel_UI form.ui)
QT4_WRAP_CPP(ItemSelectionModel_MOC form.h)

include_directories(${include_directories} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(ItemSelectionModel main.cpp form.h form.cpp ${ItemSelectionModel_UI} ${ItemSelectionModel_MOC})
TARGET_LINK_LIBRARIES(ItemSelectionModel ${QT_LIBRARIES})

</source>

Qt/ModelView/ListViewComboBox

2011-12-21T02:21:10Z

==main.cpp==
<source lang="cpp">
#include <QApplication>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Form form;

form.show();
return app.exec();
}
</source>

==ComboBoxDelegate.h==
<source lang="cpp">
#ifndef COMBOBOXDELEGATE_H
#define COMBOBOXDELEGATE_H

#include <string>
#include <vector>

#include <QItemDelegate>

class QModelIndex;
class QWidget;
class QVariant;

class ComboBoxDelegate : public QItemDelegate
{
Q_OBJECT
public:
ComboBoxDelegate(QObject *parent = 0);

QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const;
void setEditorData(QWidget *editor, const QModelIndex &index) const;
void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const;
void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const;
void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const;

private:
std::vector<std::string> Items;

};
#endif

</source>

==ComboBoxDelegate.cpp==
<source lang="cpp">
#include "ComboBoxDelegate.h"

#include <QComboBox>
#include <QWidget>
#include <QModelIndex>
#include <QApplication>
#include <QString>

#include <iostream>

ComboBoxDelegate::ComboBoxDelegate(QObject *parent)
:QItemDelegate(parent)
{
Items.push_back("Test0");
Items.push_back("Test1");
Items.push_back("Test2");
}

QWidget *ComboBoxDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &/* option */, const QModelIndex &/* index */) const
{
QComboBox* editor = new QComboBox(parent);
for(unsigned int i = 0; i < Items.size(); ++i)
{
editor->addItem(Items[i].c_str());
}
return editor;
}

void ComboBoxDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
{
QComboBox *comboBox = static_cast<QComboBox*>(editor);
int value = index.model()->data(index, Qt::EditRole).toUInt();
comboBox->setCurrentIndex(value);
}

void ComboBoxDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
{
QComboBox *comboBox = static_cast<QComboBox*>(editor);
model->setData(index, comboBox->currentIndex(), Qt::EditRole);
}

void ComboBoxDelegate::updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &/* index */) const
{
editor->setGeometry(option.rect);
}

void ComboBoxDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
QStyleOptionViewItemV4 myOption = option;
QString text = Items[index.row()].c_str();

myOption.text = text;

QApplication::style()->drawControl(QStyle::CE_ItemViewItem, &myOption, painter);
}

</source>

==form.h==
<source lang="cpp">
#ifndef FORM_H
#define FORM_H

#include "ui_form.h"

#include <QMainWindow>

#include "ComboBoxDelegate.h"

class QStringListModel;

class Form : public QMainWindow, private Ui::MainWindow
{
Q_OBJECT

public:
Form(QWidget *parent = 0);

public slots:
void on_btnAdd_clicked();
void slot_modelChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);

protected:
QStringListModel* Model;
ComboBoxDelegate Delegate;
};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include <QtGui>

#include <iostream>

#include "form.h"

Form::Form(QWidget *parent)
: QMainWindow(parent)
{
setupUi(this);

this->Model = new QStringListModel;
this->listView->setModel(this->Model);
connect(this->Model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(slot_modelChanged(QModelIndex,QModelIndex)));

this->listView->setItemDelegate(&this->Delegate);
}

void Form::on_btnAdd_clicked()
{
this->Model->insertRows(this->Model->rowCount(), 1);
this->Model->setData(this->Model->index(this->Model->rowCount()-1), "new line " + QString::number(this->Model->rowCount()));
}

void Form::slot_modelChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
{
std::cout << "Model changed." << std::endl;

// Make the combo boxes always displayed.
for ( int i = 0; i < this->Model->rowCount(); ++i )
{
this->listView->openPersistentEditor( this->Model->index(i) );
}
}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>232</width>
<height>489</height>
</rect>
</property>
<property name="windowTitle">
<string>MainWindow</string>
</property>
<widget class="QWidget" name="centralwidget">
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QListView" name="listView"/>
</item>
<item>
<widget class="QPushButton" name="btnAdd">
<property name="text">
<string>Add</string>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QMenuBar" name="menubar">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>232</width>
<height>20</height>
</rect>
</property>
<widget class="QMenu" name="menuFile">
<property name="title">
<string>File</string>
</property>
<addaction name="actionSave"/>
</widget>
<addaction name="menuFile"/>
</widget>
<widget class="QStatusBar" name="statusBar"/>
<action name="actionSave">
<property name="text">
<string>Save</string>
</property>
</action>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(ListViewSubclass)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(ListViewSubclass_UI form.ui)
QT4_WRAP_CPP(ListViewSubclass_MOC form.h ComboBoxDelegate.h)

include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(ListViewSubclass main.cpp form.h form.cpp ComboBoxDelegate.cpp ${ListViewSubclass_UI} ${ListViewSubclass_MOC})
TARGET_LINK_LIBRARIES(ListViewSubclass ${QT_LIBRARIES})

</source>

CPP/StaticInheritance

2011-12-19T19:49:22Z

Daviddoria: Created page with '==StaticInheritance.cpp== <source lang="cpp"> #include <iostream> class Parent { public: static double GetValue(); }; double Parent::GetValue() { return 2.0; } class Child…'

==StaticInheritance.cpp==
<source lang="cpp">
#include <iostream>

class Parent
{
public:
static double GetValue();
};

double Parent::GetValue()
{
return 2.0;
}

class ChildWithReimplement : public Parent
{
public:
static double GetValue();
};

double ChildWithReimplement::GetValue()
{
double parentValue = Parent::GetValue();
return parentValue + 3.0;
}

class Child : public Parent
{

};

int main(int argc, char* argv[])
{
std::cout << "parent: " << Parent::GetValue() << std::endl;

std::cout << "child: " << Child::GetValue() << std::endl;

std::cout << "ChildWithReimplement: " << ChildWithReimplement::GetValue() << std::endl;

return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(StaticInheritance)

ADD_EXECUTABLE(StaticInheritance StaticInheritance.cpp)

</source>

Qt/ModelView/AbstractListModelFileDialog

2011-12-18T21:39:24Z

Daviddoria: /* AbstractListModelFileDialog.cpp */

==main.cpp==
<source lang="cpp">
#include <QApplication>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Form form;

form.show();
return app.exec();
}

</source>

==AbstractListModelFileDialog.h==
<source lang="cpp">
#ifndef AbstractListModel_H
#define AbstractListModel_H

#include <QAbstractListModel>

#include <QVector>

class Item
{
public:
Item(const QString& name = QString()) : Name(name){}
QString Name;
};

class AbstractListModel : public QAbstractListModel
{
public:
AbstractListModel();

QVariant data(const QModelIndex& index, int role) const;

bool setData (const QModelIndex &index, const QVariant &value, int role);

int rowCount(const QModelIndex &parent=QModelIndex() ) const;

int setItems(const QVector<Item>& items);

Qt::ItemFlags flags (const QModelIndex &index ) const;

protected:
QVector<Item> Items;
};

#endif

</source>

==AbstractListModelFileDialog.cpp==
<source lang="cpp">
#include "AbstractListModelFileDialog.h"

#include <iostream>

int AbstractListModel::setItems(const QVector<Item>& items)
{
emit beginResetModel();
this->Items = items;
emit endResetModel();
}

Qt::ItemFlags AbstractListModel::flags (const QModelIndex &index ) const
{
if (index.row() < 0 || index.row() >= rowCount() || !index.isValid())
{
return Qt::NoItemFlags;
}
return Qt::ItemIsEditable | Qt::ItemIsEnabled;
}

AbstractListModel::AbstractListModel() : QAbstractListModel()
{

}

int AbstractListModel::rowCount(const QModelIndex& parent) const
{
return this->Items.size();
}

QVariant AbstractListModel::data (const QModelIndex &index , int role ) const
{
if (index.row() < 0 || index.row() >= rowCount() || !index.isValid())
{
return QVariant();
}

if (role == Qt::DisplayRole || role == Qt::EditRole)
{
return this->Items.at(index.row()).Name;
}

return QVariant();
}

bool AbstractListModel::setData (const QModelIndex &index, const QVariant &value, int role)
{
if (index.row() < 0 || index.row() >= rowCount() || !index.isValid())
{
return false;
}

if (role == Qt::DisplayRole || role == Qt::EditRole)
{
this->Items[index.row()].Name = value.toString();
}
emit dataChanged(index, index);
return true;
}

</source>

==form.h==
<source lang="cpp">
#ifndef FORM_H
#define FORM_H

#include "ui_form.h"

class AbstractListModel;

class Form : public QWidget, public Ui::Form
{
Q_OBJECT

public:
Form(QWidget *parent = 0);

public slots:
void editSlot(QModelIndex index);

protected:
AbstractListModel* Model;
};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include <QAbstractListModel>
#include <QtGui>

#include <iostream>

#include "form.h"
#include "AbstractListModelFileDialog.h"

Form::Form(QWidget *parent)
: QWidget(parent)
{
setupUi(this);

this->Model = new AbstractListModel;

connect (this->listView, SIGNAL(clicked(QModelIndex)), this, SLOT(editSlot(QModelIndex)));

QVector<Item> items;
items.push_back(Item("Test0"));
items.push_back(Item("Test1"));
items.push_back(Item("Test2"));
this->Model->setItems(items);
this->listView->setModel(this->Model);
}

void Form::editSlot(QModelIndex index)
{
if (index.row() == 0)
{
QString fileName = QFileDialog::getOpenFileName(this, "Open", "", "Files (*.*)");
this->Model->setData(index, fileName, Qt::EditRole);
}
}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="1" column="0">
<widget class="QPushButton" name="btnUpdate">
<property name="text">
<string>Update</string>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QListView" name="listView"/>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(AbstractListModelFileDialog)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs form.ui)
QT4_WRAP_CPP(MOCSrcs form.h)

include_directories(${include_directories} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(AbstractListModelFileDialog main.cpp AbstractListModelFileDialog.cpp form.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(AbstractListModelFileDialog ${QT_LIBRARIES})

</source>

Qt/ModelView/AbstractListModelCheckable

2011-12-18T14:59:56Z

Daviddoria: Fixed - cannot use bool to represent a Qt::CheckState

==main.cpp==
<source lang="cpp">
#include <QApplication>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Form form;

form.show();
return app.exec();
}

</source>

==AbstractListModelCheckable.h==
<source lang="cpp">
#ifndef AbstractListModelCheckable_H
#define AbstractListModelCheckable_H

#include <QAbstractListModel>

#include <QVector>

class Item
{
public:
Item(const QString& name = QString(), const Qt::CheckState displayed = Qt::Unchecked) :
Name(name), Displayed(displayed){}
QString Name;
Qt::CheckState Displayed;
};

class AbstractListModelCheckable : public QAbstractListModel
{
public:
AbstractListModelCheckable();

QVariant data(const QModelIndex& index, int role) const;

bool setData (const QModelIndex &index, const QVariant &value, int role);

int rowCount(const QModelIndex &parent=QModelIndex() ) const;

int setItems(const QVector<Item>& items);

Qt::ItemFlags flags (const QModelIndex &index ) const;

protected:
QVector<Item> Items;
};

#endif

</source>

==AbstractListModelCheckable.cpp==
<source lang="cpp">
#include "AbstractListModelCheckable.h"

#include <iostream>

int AbstractListModelCheckable::setItems(const QVector<Item>& items)
{
emit beginResetModel();
this->Items = items;
emit endResetModel();
}

Qt::ItemFlags AbstractListModelCheckable::flags (const QModelIndex &index ) const
{
if (index.row() < 0 || index.row() >= rowCount() || !index.isValid())
{
return Qt::NoItemFlags;
}
return Qt::ItemIsUserCheckable | Qt::ItemIsEditable | Qt::ItemIsEnabled;
}

AbstractListModelCheckable::AbstractListModelCheckable() : QAbstractListModel()
{

}

int AbstractListModelCheckable::rowCount(const QModelIndex& parent) const
{
return this->Items.size();
}

QVariant AbstractListModelCheckable::data (const QModelIndex &index , int role ) const
{
if (index.row() < 0 || index.row() >= rowCount() || !index.isValid())
{
return QVariant();
}

if (role == Qt::DisplayRole || role == Qt::EditRole)
{
return this->Items.at(index.row()).Name;
}

if(role == Qt::CheckStateRole)
{
return this->Items[index.row()].Displayed;
}

return QVariant();
}

bool AbstractListModelCheckable::setData (const QModelIndex &index, const QVariant &value, int role)
{
if (index.row() < 0 || index.row() >= rowCount() || !index.isValid())
{
return false;
}

if(role == Qt::CheckStateRole)
{
this->Items[index.row()].Displayed = static_cast<Qt::CheckState>(value.toUInt());
}

emit dataChanged(index, index);
return true;
}

</source>

==form.h==
<source lang="cpp">
#ifndef FORM_H
#define FORM_H

#include "ui_form.h"

class Form : public QWidget, public Ui::Form
{
Q_OBJECT

public:
Form(QWidget *parent = 0);

public slots:

};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include <QAbstractTableModel>
#include <QtGui>

#include <iostream>
#include <sstream>

#include "form.h"
#include "AbstractListModelCheckable.h"

Form::Form(QWidget *parent)
: QWidget(parent)
{
setupUi(this);

AbstractListModelCheckable* model = new AbstractListModelCheckable;

QVector<Item> items;
items.push_back(Item("Test0", Qt::Unchecked));
items.push_back(Item("Test1", Qt::Checked));
items.push_back(Item("Test2", Qt::Unchecked));
model->setItems(items);
this->tableView->setModel(model);
}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<widget class="QTableView" name="tableView">
<attribute name="horizontalHeaderStretchLastSection">
<bool>true</bool>
</attribute>
</widget>
</item>
<item row="1" column="0">
<widget class="QPushButton" name="btnUpdate">
<property name="text">
<string>Update</string>
</property>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(AbstractListModelCheckable)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs form.ui)
QT4_WRAP_CPP(MOCSrcs form.h)

include_directories(${include_directories} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(AbstractListModelCheckable main.cpp AbstractListModelCheckable.cpp form.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(AbstractListModelCheckable ${QT_LIBRARIES})

</source>

Qt/ModelView/StandardItemModel

2011-12-18T14:41:48Z

Daviddoria:

==main.cpp==
<source lang="cpp">
#include <QApplication>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Form form;

form.show();
return app.exec();
}

</source>

==form.h==
<source lang="cpp">
#ifndef FORM_H
#define FORM_H

#include "ui_form.h"

class Form : public QWidget, public Ui::Form
{
Q_OBJECT

public:
Form(QWidget *parent = 0);

};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include <QtGui>

#include <iostream>

#include "form.h"

Form::Form(QWidget *parent)
: QWidget(parent)
{
setupUi(this);

QStandardItemModel* model = new QStandardItemModel;

QStandardItem item0("test");
QList<QStandardItem*> items;
items.insert(0, &item0);
model->appendRow (items);

this->tableView->setModel(model);
}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<widget class="QPushButton" name="btnUpdate">
<property name="geometry">
<rect>
<x>40</x>
<y>230</y>
<width>91</width>
<height>28</height>
</rect>
</property>
<property name="text">
<string>Update</string>
</property>
</widget>
<widget class="QTableView" name="tableView">
<property name="geometry">
<rect>
<x>80</x>
<y>10</y>
<width>256</width>
<height>192</height>
</rect>
</property>
</widget>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(StandardItemModel)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs form.ui)
QT4_WRAP_CPP(MOCSrcs form.h)

include_directories(${include_directories} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(StandardItemModel main.cpp form.h form.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(StandardItemModel ${QT_LIBRARIES})

</source>

Qt/ModelView/StringListModelCheckable

2011-12-17T23:22:44Z

==main.cpp==
<source lang="cpp">
#include <QApplication>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Form form;

form.show();
return app.exec();
}

</source>

==form.h==
<source lang="cpp">
#ifndef FORM_H
#define FORM_H

#include "ui_form.h"

class Form : public QWidget, public Ui::Form
{
Q_OBJECT

public:
Form(QWidget *parent = 0);

};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include <QStringListModel>
#include <QtGui>

#include <iostream>

#include "form.h"

class CheckableStringListModel : public QStringListModel
{

public:
void setMyStringList(const QStringList &strings)
{
emit beginResetModel();
CheckedStatus.resize(strings.size());
for(unsigned int i = 0; i < CheckedStatus.size(); ++i)
{
CheckedStatus[i] = Qt::Unchecked;
}
setStringList(strings);
emit endResetModel();
}

private:
QVector<Qt::CheckState> CheckedStatus;

Qt::ItemFlags flags(const QModelIndex& index) const
{
// If the index is not valid
if (index.row() < 0 || index.row() >= rowCount())
{
return Qt::NoItemFlags;
}

return Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable;
}

QVariant data (const QModelIndex &index , int role ) const
{
// From QStringListModel
if (index.row() < 0 || index.row() >= rowCount())
{
return QVariant();
}

if (role == Qt::DisplayRole || role == Qt::EditRole)
{
return stringList().at(index.row());
}

if(role == Qt::CheckStateRole)
{
return CheckedStatus[index.row()];
}

return QVariant();
}

bool setData (const QModelIndex &index, const QVariant &value, int role)
{
// From QStringListModel
if (index.row() < 0 || index.row() >= rowCount())
{
return false;
}

if(role == Qt::EditRole || role == Qt::DisplayRole)
{
stringList().replace(index.row(), value.toString());
emit dataChanged(index, index);
return true;
}
if(role == Qt::CheckStateRole)
{
//CheckedStatus[index.row()] = value.value<Qt::CheckState>();
CheckedStatus[index.row()] = static_cast<Qt::CheckState>(value.toUInt());

emit dataChanged(index, index);
}
return true;

}
};

Form::Form(QWidget *parent) : QWidget(parent)
{
setupUi(this);

CheckableStringListModel* model = new CheckableStringListModel;

QStringList list;
list << "a" << "b" << "c";
model->setMyStringList(list);
this->listView->setModel(model);
}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<widget class="QListView" name="listView"/>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(StringListModelCheckable)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs form.ui)
QT4_WRAP_CPP(MOCSrcs form.h)

include_directories(${include_directories} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(StringListModelCheckable main.cpp form.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(StringListModelCheckable ${QT_LIBRARIES})

</source>

Qt/Delegates/ComboBoxDelegate

2011-12-11T17:20:35Z

Nelson Barata: /* main.cpp */

==main.cpp==
<source lang="cpp">
#include <QApplication>
#include <QHeaderView>
#include <QItemSelectionModel>
#include <QStandardItemModel>
#include <QTableView>

#include <iostream>

#include "ComboBoxDelegate.h"

int main(int argc, char *argv[])
{
std::cout << "Enter." << std::endl;
QApplication app(argc, argv);

QStandardItemModel model(4, 2);
QTableView tableView;
tableView.setModel(&model);

ComboBoxDelegate* delegate = new ComboBoxDelegate(this);
//tableView.setItemDelegate(&delegate);
tableView.setItemDelegateForColumn(1, delegate); // Column 0 can take any value, column 1 can only take values up to 8.

for (int row = 0; row < 4; ++row)
{
for (int column = 0; column < 2; ++column)
{
QModelIndex index = model.index(row, column, QModelIndex());
int value = (row+1) * (column+1);
std::cout << "Setting (" << row << ", " << column << ") to " << value << std::endl;
model.setData(index, QVariant(value));
}
}

// Make the combo boxes always displayed.
for ( int i = 0; i < model.rowCount(); ++i )
{
tableView.openPersistentEditor( model.index(i, 1) );
}

tableView.show();
return app.exec();
}

</source>

==ComboBoxDelegate.h==
<source lang="cpp">
#ifndef COMBOBOXDELEGATE_H
#define COMBOBOXDELEGATE_H

#include <string>
#include <vector>

#include <QItemDelegate>

class QModelIndex;
class QWidget;
class QVariant;

class ComboBoxDelegate : public QItemDelegate
{
Q_OBJECT
public:
ComboBoxDelegate(QObject *parent = 0);

QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const;
void setEditorData(QWidget *editor, const QModelIndex &index) const;
void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const;
void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const;
void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const;

private:
std::vector<std::string> Items;

};
#endif

</source>

==ComboBoxDelegate.cpp==
<source lang="cpp">
#include "ComboBoxDelegate.h"

#include <QComboBox>
#include <QWidget>
#include <QModelIndex>
#include <QApplication>
#include <QString>

#include <iostream>

ComboBoxDelegate::ComboBoxDelegate(QObject *parent)
:QItemDelegate(parent)
{
Items.push_back("Test0");
Items.push_back("Test1");
Items.push_back("Test2");
Items.push_back("Test3");
Items.push_back("Test4");
Items.push_back("Test5");
Items.push_back("Test6");
Items.push_back("Test7");
Items.push_back("Test8");
}

QWidget *ComboBoxDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &/* option */, const QModelIndex &/* index */) const
{
QComboBox* editor = new QComboBox(parent);
for(unsigned int i = 0; i < Items.size(); ++i)
{
editor->addItem(Items[i].c_str());
}
return editor;
}

void ComboBoxDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
{
QComboBox *comboBox = static_cast<QComboBox*>(editor);
int value = index.model()->data(index, Qt::EditRole).toUInt();
comboBox->setCurrentIndex(value);
}

void ComboBoxDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
{
QComboBox *comboBox = static_cast<QComboBox*>(editor);
model->setData(index, comboBox->currentIndex(), Qt::EditRole);
}

void ComboBoxDelegate::updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &/* index */) const
{
editor->setGeometry(option.rect);
}

void ComboBoxDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
QStyleOptionViewItemV4 myOption = option;
QString text = Items[index.row()].c_str();

myOption.text = text;

QApplication::style()->drawControl(QStyle::CE_ItemViewItem, &myOption, painter);
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(ComboBoxDelegate)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_CPP(MOCSrcs ComboBoxDelegate.h)

include_directories(${include_directories} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(ComboBoxDelegate main.cpp
ComboBoxDelegate.cpp
${MOCSrcs}
)
TARGET_LINK_LIBRARIES(ComboBoxDelegate ${QT_LIBRARIES})

</source>

Qt/Databases/ListView

2011-12-11T14:17:24Z

Daviddoria: /* form.cpp */ Fixed - must use a pointer or the model goes out of scope

==ListView.cpp==
<source lang="cpp">
#include <QApplication>
#include <QSqlDatabase>
#include <QSqlError>
#include <QSqlQuery>
#include <QVariant>
#include <QFile>

#include <iostream>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);

QFile::remove ("test.sqlite");

QSqlDatabase database = QSqlDatabase::addDatabase("QSQLITE");
database.setDatabaseName("test.sqlite");
if(!database.open())
{
std::cerr << "Could not open database" << std::endl;
std::cerr << "Last error: " << database.lastError().text().toStdString() << std::endl;
}

QSqlQuery createQuery;
bool createSuccess = createQuery.exec("create table AssociateTable "
"(id integer primary key, "
"AssociateName TEXT, "
"SocialSecurityNumber TEXT)");

if(createSuccess)
{
std::cout << "Table created successfully!" << std::endl;
}
else
{
std::cerr << "Could not create table." << std::endl;
std::cerr << "Last database error: " << database.lastError().text().toStdString() << std::endl;
std::cerr << "Last query error: " << createQuery.lastError().text().toStdString() << std::endl;
}

// Populate the table with default values
QSqlQuery insertQuery;
insertQuery.prepare("INSERT INTO AssociateTable (id, AssociateName, SocialSecurityNumber) "
"VALUES (:id, :AssociateName, :SocialSecurityNumber)");
insertQuery.bindValue(":id", 0);
insertQuery.bindValue(":AssociateName", "AssociateName");
insertQuery.bindValue(":SocialSecurityNumber", "SocialSecurityNumber");

bool insertSuccess = insertQuery.exec();
if(!insertSuccess)
{
std::cerr << "Could not insert values!" << std::endl;
std::cerr << "insertQuery last error: " << insertQuery.lastError().text().toStdString() << std::endl;
return -1;
}

MyForm form;

form.show();
return app.exec();
}

</source>

==form.h==
<source lang="cpp">
#ifndef ListView_H
#define ListView_H

#include "ui_ListView.h"

class MyForm : public QWidget, private Ui::Form
{
Q_OBJECT
public:
MyForm(QWidget *parent = 0);

public slots:

protected:
void showEvent ( QShowEvent * event );
};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include "form.h"

#include <iostream>

#include <QSqlDatabase>
#include <QStringList>
#include <QSqlQuery>
#include <QDebug>
#include <QSqlError>
#include <QVariant>
#include <QSqlTableModel>
#include <QSqlRecord>

MyForm::MyForm(QWidget *parent) : QWidget(parent)
{
setupUi(this);
}

void MyForm::showEvent ( QShowEvent * event )
{
QSqlQuery selectQuery;
selectQuery.prepare("SELECT AssociateName FROM AssociateTable");

bool insertSuccess = selectQuery.exec();
if(!insertSuccess)
{
std::cerr << "Error selecting associates!" << std::endl;
std::cerr << "Last error: " << selectQuery.lastError().text().toStdString() << std::endl;
return;
}

QSqlTableModel* tableModel = new QSqlTableModel;
tableModel->setTable("AssociateTable");

tableModel->select();

this->listView->setModel(tableModel);
this->listView->setModelColumn(2);
}

</source>

==ListView.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>772</width>
<height>624</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<widget class="QPushButton" name="pushButton">
<property name="geometry">
<rect>
<x>330</x>
<y>450</y>
<width>91</width>
<height>27</height>
</rect>
</property>
<property name="text">
<string>PushButton</string>
</property>
</widget>
<widget class="QListView" name="listView">
<property name="geometry">
<rect>
<x>260</x>
<y>90</y>
<width>256</width>
<height>192</height>
</rect>
</property>
</widget>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(ListView)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs ListView.ui)
QT4_WRAP_CPP(MOCSrcs form.h)

include_directories(${include_directories} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
INCLUDE_DIRECTORIES(${QT_QTSQL_INCLUDE_DIR})

ADD_EXECUTABLE(ListView ListView.cpp form.h form.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(ListView ${QT_LIBRARIES} ${QT_QTSQL_LIBRARY_RELEASE})

</source>

Qt/ModelView/ComboBoxOfCheckBoxes

2011-12-07T21:22:13Z

Daviddoria:

==demo.cpp==
<source lang="cpp">
#include <QApplication>

#include "main.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
MainWindow window;
window.show();
return app.exec();
}

</source>

==main.h==
<source lang="cpp">
#ifndef MainWindow_H
#define MainWindow_H

#include <QMainWindow>
#include <QStandardItemModel>

#include "ui_main.h"

class MainWindow : public QMainWindow, public Ui::MainWindow
{
Q_OBJECT

public:
MainWindow(QMainWindow *parent = 0);

public slots:

//void slot_changed();
void slot_changed(const QModelIndex&, const QModelIndex&);

protected:
QStandardItemModel* Model;
QStandardItem* Item1;
QStandardItem* Item2;

std::vector<QStandardItem*> Items;
};

#endif

</source>

==main.cpp==
<source lang="cpp">

#include <QtGui>

#include <iostream>

#include "main.h"

MainWindow::MainWindow(QMainWindow* parent) : QMainWindow(parent)
{
setupUi(this);
this->Model = new QStandardItemModel;
this->Item1 = new QStandardItem;

this->Item1->setText("test");
this->Item1->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
this->Item1->setData(Qt::Unchecked, Qt::CheckStateRole);

this->Item2 = new QStandardItem;
this->Item2->setText("test2");
this->Item2->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
this->Item2->setData(Qt::Unchecked, Qt::CheckStateRole);

connect(this->Model, SIGNAL(dataChanged ( const QModelIndex&, const QModelIndex&)), this, SLOT(slot_changed(const QModelIndex&, const QModelIndex&)));

this->Model->insertRow(0, this->Item1);
this->Model->insertRow(1, this->Item2);

this->Items.push_back(this->Item1);
this->Items.push_back(this->Item2);

this->comboBox->setModel(this->Model);

std::cout << comboBox->model()->rowCount() << " rows after." << std::endl;
}

void MainWindow::slot_changed(const QModelIndex& topLeft, const QModelIndex& bottomRight)
{
//std::cout << "topLeft: " << topLeft.row() << std::endl;
//std::cout << "bottomRight: " << bottomRight.row() << std::endl;
std::cout << "Item " << topLeft.row() << " " << std::endl;
QStandardItem* item = this->Items[topLeft.row()];
if(item->checkState() == Qt::Unchecked)
{
std::cout << "Unchecked!" << std::endl;
}
else if(item->checkState() == Qt::Checked)
{
std::cout << "Checked!" << std::endl;
}

}

</source>

==main.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>800</width>
<height>600</height>
</rect>
</property>
<property name="windowTitle">
<string>MainWindow</string>
</property>
<widget class="QWidget" name="centralwidget">
<widget class="QComboBox" name="comboBox">
<property name="geometry">
<rect>
<x>240</x>
<y>150</y>
<width>211</width>
<height>27</height>
</rect>
</property>
<item>
<property name="text">
<string>Item1</string>
</property>
</item>
<item>
<property name="text">
<string>Item2</string>
</property>
</item>
</widget>
</widget>
<widget class="QMenuBar" name="menubar">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>800</width>
<height>25</height>
</rect>
</property>
</widget>
<widget class="QStatusBar" name="statusbar"/>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(ComboBoxOfCheckBoxes)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

include_directories(${include_directories} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

QT4_WRAP_UI(UISrcs main.ui)
QT4_WRAP_CPP(MOCSrcs main.h)

ADD_EXECUTABLE(ComboBoxOfCheckBoxes demo.cpp main.h main.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(ComboBoxOfCheckBoxes ${QT_LIBRARIES})

</source>

CPP/Math/Median

2011-12-02T15:52:51Z

Daviddoria: Created page with '==Median.cpp== <source lang="cpp"> #include <algorithm> #include <iostream> #include <cmath> #include <vector> template<typename T> T VectorMedian(std::vector<T> v) { int n = …'

==Median.cpp==
<source lang="cpp">
#include <algorithm>
#include <iostream>
#include <cmath>
#include <vector>

template<typename T>
T VectorMedian(std::vector<T> v)
{
int n = v.size() / 2;
std::nth_element(v.begin(), v.begin()+n, v.end());
return v[n];
}

int main(int argc, char *argv[])
{
// std::vector<int> v;
// v.push_back(1);
// v.push_back(3);
// v.push_back(2);

// std::cout << VectorMedian<int>(v) << std::endl;

std::vector<float> v;
v.push_back(1.0);
v.push_back(3.1);
v.push_back(2.2);

std::cout << VectorMedian<float>(v) << std::endl;
return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(Median)
ADD_EXECUTABLE(Median Median.cpp )

</source>

Qt/Utilities/HandleItem

2011-11-18T21:00:09Z

Daviddoria: /* HandleItem.cpp */

==HandleItem.cpp==
<source lang="cpp">
#include <QApplication>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Form form;

form.show();
return app.exec();
}

</source>

==form.h==
<source lang="cpp">
#ifndef FORM_H
#define FORM_H

#include "ui_form.h"

class Form : public QWidget, private Ui::Form
{
Q_OBJECT

public slots:

public:
Form(QWidget *parent = 0);

};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include <QtGui>

#include "form.h"
#include "HandleItem.h"

#include <iostream>

Form::Form(QWidget *parent) : QWidget(parent)
{
setupUi(this);

QGraphicsScene* scene = new QGraphicsScene( 0, 0, 200, 200 );
QGraphicsRectItem *rectItem = new QGraphicsRectItem( QRect( 10, 10, 50, 100 ), 0, scene );

// The center handle must know about all of the other handles so it can translate them with the object
HandleItem *topHandle = new HandleItem( rectItem, scene, Qt::red, HandleItem::TopHandle );
HandleItem *rightHandle = new HandleItem( rectItem, scene, Qt::red, HandleItem::RightHandle );
HandleItem *leftHandle = new HandleItem( rectItem, scene, Qt::red, HandleItem::LeftHandle );
HandleItem *bottomHandle = new HandleItem( rectItem, scene, Qt::red, HandleItem::BottomHandle );
HandleItem *centerHandle = new HandleItem( rectItem, scene, Qt::red, HandleItem::CenterHandle, QList<HandleItem*>() << topHandle << rightHandle << leftHandle << bottomHandle );

this->graphicsView->setScene( scene );

}

</source>

==HandleItem.h==
<source lang="cpp">
#ifndef HANDLEITEM_H
#define HANDLEITEM_H

#include <QGraphicsItem>
#include <QGraphicsRectItem>

class HandleItem;

class HandleItem : public QGraphicsItem
{
public:

enum HandleRole
{
CenterHandle,
RightHandle,
TopHandle,
LeftHandle,
BottomHandle
};

HandleItem( QGraphicsRectItem *item, QGraphicsScene *scene, QColor color, HandleRole role = CenterHandle, QList<HandleItem*> handles = QList<HandleItem*>() );

void paint( QPainter *paint, const QStyleOptionGraphicsItem *option, QWidget *widget );
QRectF boundingRect() const;

protected:
void mousePressEvent( QGraphicsSceneMouseEvent *event );
void mouseReleaseEvent( QGraphicsSceneMouseEvent *event );

QVariant itemChange( GraphicsItemChange change, const QVariant &data );

private:
QGraphicsRectItem *m_item;

HandleRole m_role;
QColor m_color;

QList<HandleItem*> m_handles;

bool m_pressed;
};

#endif // HANDLEITEM_H

</source>

==HandleItem.cpp==
<source lang="cpp">
#include "HandleItem.h"

#include <QPainter>
#include <QPointF>

#include <cmath>
#include <iostream>

HandleItem::HandleItem( QGraphicsRectItem *item, QGraphicsScene *scene, QColor color, HandleItem::HandleRole role, QList<HandleItem*> handles ) : QGraphicsItem( 0, scene )
{
m_role = role;
m_color = color;

m_item = item;
m_handles = handles;

m_pressed = false;
setZValue( 100 );

setFlag( ItemIsMovable );
setFlag(ItemSendsGeometryChanges);
}

void HandleItem::paint( QPainter *paint, const QStyleOptionGraphicsItem *option, QWidget *widget )
{
paint->setPen( m_color );
paint->setBrush( m_color );

QRectF rect = boundingRect();
QVector<QPointF> points;

switch( m_role )
{
case RightHandle:
points << rect.center()+QPointF(3,0) << rect.center()+QPointF(-3,-5) << rect.center()+QPointF(-3,5);
paint->drawConvexPolygon( QPolygonF(points) );
break;
case LeftHandle:
points << rect.center()+QPointF(-3,0) << rect.center()+QPointF(3,-5) << rect.center()+QPointF(3,5);
paint->drawConvexPolygon( QPolygonF(points) );
break;
case TopHandle:
points << rect.center()+QPointF(0,-3) << rect.center()+QPointF(-5,3) << rect.center()+QPointF(5,3);
paint->drawConvexPolygon( QPolygonF(points) );
break;
case BottomHandle:
points << rect.center()+QPointF(0,3) << rect.center()+QPointF(-5,-3) << rect.center()+QPointF(5,-3);
paint->drawConvexPolygon( QPolygonF(points) );
break;
}
}

QRectF HandleItem::boundingRect() const
{
switch( m_role )
{
case LeftHandle:
{
QPointF point(m_item->boundingRect().left() - pos().x(), m_item->boundingRect().top() + m_item->boundingRect().height()/2);
return QRectF( point-QPointF(3, 5), QSize( 6, 10 ) );
}
case RightHandle:
{
QPointF point(m_item->boundingRect().right() - pos().x(), m_item->boundingRect().top() + m_item->boundingRect().height()/2);
return QRectF( point-QPointF(3, 5), QSize( 6, 10 ) );
}
case TopHandle:
{
QPointF point(m_item->boundingRect().left() + m_item->boundingRect().width()/2, m_item->boundingRect().top() - pos().y());
return QRectF( point-QPointF(5, 3), QSize( 10, 6 ) );
}
case BottomHandle:
{
QPointF point(m_item->boundingRect().left() + m_item->boundingRect().width()/2, m_item->boundingRect().bottom() - pos().y());
return QRectF( point-QPointF(5, 3), QSize( 10, 6 ) );
}
}

return QRectF();
}

QVariant HandleItem::itemChange( GraphicsItemChange change, const QVariant &data )
{
if( change == ItemPositionChange && m_pressed )
{

QPointF movement;
QPointF newData = data.toPointF();
QRectF newRect = m_item->rect();

switch( m_role )
{
case LeftHandle:
{
// Prevent the rectangle from collapsing.
//if( fabs(movement.x()) <= 5 )
if(m_item->rect().width() < 5)
{
std::cout << "too small! " << std::endl;
return QGraphicsItem::itemChange( change, newData );
}

// Snap the movement to the X direction
newData.setY(0);

movement = newData - pos();
// Resize the rectangle
newRect.setLeft(m_item->rect().left() + movement.x());

m_item->setRect(newRect);

break;
}
case RightHandle:
{
// Prevent the rectangle from collapsing.
//if( fabs(movement.x()) <= 5 )
//if(m_item->rect().width() < 5)
if(m_item->rect().width() + movement.x() < 5)
{
std::cout << "too small! " << std::endl;
return QGraphicsItem::itemChange( change, newData );
}

// Snap the movement to the X direction
newData.setY(0);

movement = newData - pos();
// Resize the rectangle
newRect.setRight(m_item->rect().right() + movement.x());

m_item->setRect(newRect);

break;
}
case TopHandle:
{
// Prevent the rectangle from collapsing.
//if( fabs(movement.x()) <= 5 )
if(m_item->rect().height() < 5)
{
std::cout << "too small! " << std::endl;
return QGraphicsItem::itemChange( change, newData );
}

// Snap the movement to the Y direction
newData.setX(0);

movement = newData - pos();
// Resize the rectangle
newRect.setTop(m_item->rect().top() + movement.y());

m_item->setRect(newRect);

break;
}
case BottomHandle:
{
// Prevent the rectangle from collapsing.
//if( fabs(movement.x()) <= 5 )
if(m_item->rect().height() < 5)
{
std::cout << "too small! " << std::endl;
return QGraphicsItem::itemChange( change, newData );
}

// Snap the movement to the Y direction
newData.setX(0);

movement = newData - pos();
// Resize the rectangle
newRect.setBottom(m_item->rect().bottom() + movement.y());

m_item->setRect(newRect);

break;
}
} // end switch

return QGraphicsItem::itemChange( change, newData);
} // end if pressed

return QGraphicsItem::itemChange( change, data );
}

void HandleItem::mousePressEvent( QGraphicsSceneMouseEvent *event )
{
m_pressed = true;
QGraphicsItem::mousePressEvent( event );
}

void HandleItem::mouseReleaseEvent( QGraphicsSceneMouseEvent *event )
{
m_pressed = false;
QGraphicsItem::mouseReleaseEvent( event );
}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<widget class="QGraphicsView" name="graphicsView">
<property name="geometry">
<rect>
<x>80</x>
<y>50</y>
<width>256</width>
<height>192</height>
</rect>
</property>
</widget>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(HandleItem)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs form.ui)
QT4_WRAP_CPP(MOCSrcs form.h)

include_directories(${include_directories} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(HandleItem main.cpp HandleItem.cpp form.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(HandleItem ${QT_LIBRARIES})

</source>

Qt/QWT/Plot

2011-11-17T19:01:41Z

Daviddoria:

==main.cpp==
<source lang="cpp">
#include <QApplication>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
MyForm form;

form.show();
return app.exec();
}

</source>

==form.h==
<source lang="cpp">
#ifndef BUTTONFORM_H
#define BUTTONFORM_H

#include "ui_form.h"

class MyForm : public QWidget, private Ui::Form
{
Q_OBJECT

public:
MyForm(QWidget *parent = 0);

public slots:

};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include "form.h"

#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_series_data.h>

MyForm::MyForm(QWidget *parent) : QWidget(parent)
{
setupUi(this);

QwtPlot *myPlot = new QwtPlot(this);

QwtPlotCurve *curve1 = new QwtPlotCurve("Curve 1");

QwtPointSeriesData* myData = new QwtPointSeriesData;

QVector<QPointF>* samples = new QVector<QPointF>;
samples->push_back(QPointF(1.0,1.0));
samples->push_back(QPointF(2.0,2.0));
samples->push_back(QPointF(3.0,3.0));
samples->push_back(QPointF(4.0,5.0));
myData->setSamples(*samples);
curve1->setData(myData);

curve1->attach(myPlot);

myPlot->replot();
}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string>My Program</string>
</property>

</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(QWT)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs form.ui)
QT4_WRAP_CPP(MOCSrcs form.h)

include_directories(${include_directories} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} /home/doriad/src/qwt-6.0/src)
link_directories(/home/doriad/src/qwt-6.0/lib)

ADD_EXECUTABLE(QWT main.cpp form.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(QWT ${QT_LIBRARIES} qwt)

</source>

CPP/Boost/LexicalCast

2011-11-17T14:44:26Z

Daviddoria: Created page with '==LexicalCast.cpp== <source lang="cpp"> #include <iostream> #include <boost/lexical_cast.hpp> int main(int argc, char* argv[]) { std::string stringNumber = "2.0"; float flo…'

==LexicalCast.cpp==
<source lang="cpp">
#include <iostream>

#include <boost/lexical_cast.hpp>

int main(int argc, char* argv[])
{
std::string stringNumber = "2.0";
float floatNumber = boost::lexical_cast<float>(stringNumber);

std::cout << floatNumber << std::endl;

return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(LexicalCast)

FIND_PACKAGE(Boost)

LINK_DIRECTORIES(${LINK_DIRECTORIES} ${Boost_LIBRARY_DIRS})
INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${Boost_INCLUDE_DIRS})

ADD_EXECUTABLE(LexicalCast LexicalCast.cpp)

</source>

Qt/Images/RubberBandSignal

2011-11-16T17:24:17Z

==main.cpp==
<source lang="cpp">
#include <QApplication>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Form form;

form.show();
return app.exec();
}

</source>

==form.h==
<source lang="cpp">
#ifndef FORM_H
#define FORM_H

#include "ui_form.h"

class Form : public QWidget, private Ui::Form
{
Q_OBJECT
public slots:

public:
Form(QWidget *parent = 0);

};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include <QtGui>
#include <QImage>
#include <QRubberBand>
#include <QGraphicsView>

#include "form.h"

#include <iostream>

class MyGraphicsView : public QGraphicsView
{
public:

MyGraphicsView( QWidget * parent = 0 ) : QGraphicsView(parent){}

void mouseReleaseEvent(QMouseEvent *event);
void mouseMoveEvent(QMouseEvent *event);
void mousePressEvent(QMouseEvent *event);
};

void MyGraphicsView::mousePressEvent(QMouseEvent *event)
{
QGraphicsView::mousePressEvent(event);
QPoint point = event->pos();
std::cout << "mousePressEvent: " << point.x() << " " << point.y() << std::endl;
}

void MyGraphicsView::mouseMoveEvent(QMouseEvent *event)
{
QGraphicsView::mouseMoveEvent(event);
QPoint point = event->pos();
std::cout << "mouseMoveEvent: " << point.x() << " " << point.y() << std::endl;

}

void MyGraphicsView::mouseReleaseEvent(QMouseEvent *event)
{
QGraphicsView::mouseReleaseEvent(event);
QPoint point = event->pos();
std::cout << "mouseReleaseEvent: " << point.x() << " " << point.y() << std::endl;
}

Form::Form(QWidget *parent)
: QWidget(parent)
{
setupUi(this);

MyGraphicsView* graphicsView = new MyGraphicsView(this );
graphicsView->show();

QGraphicsScene* scene = new QGraphicsScene();
graphicsView->setScene(scene);
graphicsView->setDragMode(QGraphicsView::RubberBandDrag);
graphicsView->show();

QPixmap pixmap(100,100);
pixmap.fill(QColor(255,0,0));

QGraphicsPixmapItem* item = scene->addPixmap(pixmap);

}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>812</width>
<height>565</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(RubberbandSignal)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs form.ui)
QT4_WRAP_CPP(MOCSrcs form.h)

include_directories(${include_directories} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(RubberbandSignal main.cpp form.h form.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(RubberbandSignal ${QT_LIBRARIES})

</source>

CPP/Boost/BGL/Undirected/IterateEdges

2011-11-15T23:03:16Z

Daviddoria: use graph_traits

==IterateEdges.cpp==
<source lang="cpp">
#include <iostream>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/undirected_graph.hpp>

typedef boost::property<boost::edge_weight_t, float> EdgeWeightProperty;

typedef boost::undirected_graph<boost::no_property, EdgeWeightProperty> Graph;

int main(int,char*[])
{
// Create a graph object
Graph g;

// Add vertices
boost::graph_traits<Graph>::vertex_descriptor v0 = g.add_vertex();
boost::graph_traits<Graph>::vertex_descriptor v1 = g.add_vertex();
boost::graph_traits<Graph>::vertex_descriptor v2 = g.add_vertex();

// Add weighted edges
EdgeWeightProperty weight0 = 5;
g.add_edge(v0, v1, weight0);

EdgeWeightProperty weight1 = 3;
g.add_edge(v1, v2, weight1);

boost::property_map<Graph, boost::edge_weight_t>::type EdgeWeightMap = get(boost::edge_weight_t(), g);

typedef boost::graph_traits<Graph>::edge_iterator edge_iter;
std::pair<edge_iter, edge_iter> edgePair;
for(edgePair = edges(g); edgePair.first != edgePair.second; ++edgePair.first)
{
std::cout << EdgeWeightMap[*edgePair.first] << " ";
}

return 0;
}

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

Project(UndirectedIterateEdges)

set(Boost_USE_MULTITHREADED ON)
FIND_PACKAGE(Boost 1.38 COMPONENTS required)

INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${Boost_INCLUDE_DIRS})
LINK_DIRECTORIES(${LINK_DIRECTORIES} ${Boost_LIBRARY_DIRS})

ADD_EXECUTABLE(UndirectedIterateEdges UndirectedIterateEdges.cpp)
</source>

Boost/BGL

2011-11-15T21:12:36Z

Daviddoria:

=== Basics ===
* [[CPP/Boost/CreateGraph|Create a graph]] - This is the most fundamental process of using BGL - creating a graph. This example explains 3 methods of creating a graph, using adjacency_list directly, and also using the directed_graph and undirected_graph subclasses.
* [[CPP/Boost/BGL/EdgeExists|Check if an edge exists]] - If it does, you also get the edge_descriptor
* [[CPP/Boost/BGL/CopyAGraph|Copy a graph]]
* [[CPP/Boost/BGL/Directed/Weighted|Access an edge]]
* [[CPP/Boost/RemoveVertex|Remove a vertex from a graph]]
* [[CPP/Boost/RemoveEdge|Remove an edge from a graph]]
* [[CPP/Boost/BGL/EdgeProperties|Add properties to edges]]
* [[CPP/Boost/BGL/VertexProperties|Add properties to vertices]]
* [[CPP/Boost/BGL/BundledProperties|Bundled properties]]
* [[CPP/Boost/BGL/AdjacentVertices|Get a list of neighboring (adjacent) vertices]]
* [[CPP/Boost/BGL/DirectedGraph|Directed graphs only give access to out edges]]
* [[CPP/Boost/BGL/BidirectionalGraph|Bidirectional graphs give access to both in and out edges]]
* [[CPP/Boost/BGL/NumberOfNeighbors|Number of incoming, outgoing, and total edges]]
* [[CPP/Boost/BGL/BreadthFirstSearch|Breadth first search (BFS with a custom visitor)]]
* [[CPP/Boost/BGL/MakeBFSVisitor|Breadth first search with make_bfs_visitor]]
* [[CPP/Boost/BGL/DepthFirstSearch|Depth first search (DFS)]]

=== Filtered graphs ===
* [[CPP/Boost/BGL/FilteredGraphVertices|Filter a graph's vertices]]
* [[CPP/Boost/BGL/FilteredGraphEdges|Filter a graph's edges]]

=== Directed graphs ===
* [[CPP/Boost/BGL/Directed/IterateEdges|Iterate over all edges in a directed graph]]

=== Undirected graphs ===
* [[CPP/Boost/BGL/Undirected/IterateEdges|Iterate over all edges in an undirected graph]]

=== I/O ===
* [[Boost/BGL/IO/ReadGraph|Read a graph from a file]]
* [[Boost/BGL/IO/WriteGraph|Write a graph to a file]]
* [[Boost/BGL/RelabelInputVertices|Relabel input vertices read from a dot file so they match the labels used in the file]]

=== Algorithms ===

* [[CPP/Boost/BGL/DijkstraDirected|Find the shortest path (Dijkstra) from a specified vertex to all other vertices in a directed graph]]
* [[CPP/Boost/BGL/DijkstraUndirected|Find the shortest path (Dijkstra) from a specified vertex to all other vertices in an undirected graph]]
* [[CPP/Boost/BGL/DijkstraComputePath|Find the shortest path (Dijkstra) from one specified vertex to another specified vertex in a graph]]
* [[CPP/Boost/BGL/BetweennessCentralityClustering|Cluster a graph using betweenness centrality]]
* [[CPP/Boost/BGL/MaxFlow|Find the max flow of a graph]]
* [[CPP/Boost/BGL/PrimMST|Find the minimum spanning tree of a graph (Prim's algorithm)]]

=== Visualization ===

* [[CPP/Boost/BGL/InvisibleEdges|Create a graph with invisible edges]]

=== Grid graphs ===

* [[CPP/Boost/BGL/GridGraphProperties|Create properties on a grid graph]]
* [[CPP/Boost/BGL/d_ary_heap_indirect|Priority queue that sorts by a property (d_ary_heap_indirect)]]
* [[CPP/Boost/BGL/GridGraphVertexIterator|Grid graph vertex iterator]]

=== Utilities ===

* [[CPP/Boost/BGL/IndirectPriorityQueue|Priority queue that sorts by a property (d_ary_heap_indirect)]]

Qt/Images/RubberBand

2011-11-15T16:56:03Z

==main.cpp==
<source lang="cpp">
#include <QApplication>

#include "form.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Form form;

form.show();
return app.exec();
}

</source>

==form.h==
<source lang="cpp">
#ifndef FORM_H
#define FORM_H

#include "ui_form.h"

class Form : public QWidget, private Ui::Form
{
Q_OBJECT

public:
Form(QWidget *parent = 0);

};

#endif

</source>

==form.cpp==
<source lang="cpp">
#include <QtGui>
#include <QImage>
#include <QRubberBand>

#include "form.h"

#include <iostream>

Form::Form(QWidget *parent)
: QWidget(parent)
{
setupUi(this);

QGraphicsScene* scene = new QGraphicsScene();
//QRubberBand* rubberBand = new QRubberBand(QRubberBand::Rectangle, scene);
//QRubberBand* rubberBand = new QRubberBand(QRubberBand::Rectangle);
QRubberBand* rubberBand = new QRubberBand(QRubberBand::Rectangle, this->graphicsView);

QPalette palette;
palette.setBrush(QPalette::Foreground, QBrush(Qt::green));
palette.setBrush(QPalette::Base, QBrush(Qt::red));

rubberBand->setPalette(palette);
rubberBand->resize(30, 30);

//scene->addItem(rubberBand);

this->graphicsView->setScene(scene);
//this->graphicsView->setDragMode(QGraphicsView::RubberBandDrag);
this->graphicsView->show();
}

</source>

==form.ui==
<source lang="text">
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>812</width>
<height>565</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<widget class="QPushButton" name="btnOpen">
<property name="geometry">
<rect>
<x>20</x>
<y>10</y>
<width>121</width>
<height>41</height>
</rect>
</property>
<property name="text">
<string>Open Image</string>
</property>
</widget>
<widget class="QGraphicsView" name="graphicsView">
<property name="geometry">
<rect>
<x>80</x>
<y>80</y>
<width>521</width>
<height>361</height>
</rect>
</property>
<property name="verticalScrollBarPolicy">
<enum>Qt::ScrollBarAlwaysOff</enum>
</property>
<property name="horizontalScrollBarPolicy">
<enum>Qt::ScrollBarAlwaysOff</enum>
</property>
</widget>
</widget>
<resources/>
<connections/>
</ui>

</source>

==CMakeLists.txt==
<source lang="cmake">
cmake_minimum_required(VERSION 2.6)

PROJECT(Rubberband)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})

QT4_WRAP_UI(UISrcs form.ui)
QT4_WRAP_CPP(MOCSrcs form.h)

include_directories(${include_directories} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})

ADD_EXECUTABLE(Rubberband main.cpp form.h form.cpp ${MOCSrcs} ${UISrcs})
TARGET_LINK_LIBRARIES(Rubberband ${QT_LIBRARIES})

</source>