[ C++ ] Drawing Program.

Max_Payne · December 21, 2007, 1:03pm

I made a program that prints dots and lines in a Page. So far that's all i could come up with.
When i try to print the lines and the dots it just prints consecutive points,I want it to print the points & lines in the page's coordinates.

I have been stuck for a long time now. Please Help.

Point.h

#pragma once

#include <iostream>
using namespace std;

class Point
{
private:
	int x;
	int y;

public:
	Point(void);
	Point( int x, int y );
	Point( const Point &xPoint );
	~Point(void);

	void setX( int x );
	int getX() const;

	void setY( int y );
	int getY() const;

	Point & operator = ( const Point &xPoint );

	bool operator == ( const Point &xPoint ) const;

	bool includes( int cord_X, int cord_Y ) const;
	bool includes( const Point &xPoint ) const;

	void draw() const;
};

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

Point.cpp

#include "Point.h"

Point::Point( void )
{
	this->x = 0;
	this->y = 0;
}

Point::Point( int x, int y )
{
	this->x = x;
	this->y = y;
}

Point::Point( const Point &xPoint )
{
	this->x = xPoint.x;
	this->y = xPoint.y;
}

Point::~Point( void ) {}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

void Point::setX( int x ) // set X
{
	this->x = x;
}

void Point::setY( int y ) // set Y
{
	this->y = y;
}


int Point::getX() const // get X
{
	return ( this->x );
}

int Point::getY() const // get Y
{
	return ( this->y );
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

Point &Point::operator = ( const Point &xPoint )
{
	if( this != &xPoint )
    {
		this->x = xPoint.x;
		this->y = xPoint.y;
    }

    return ( *this );
}

bool Point::includes( int cord_X, int cord_Y ) const
{
	return ( this->x == cord_X && this->y == cord_Y );
}

void Point::draw() const
{
	cout << '.';
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

bool Point::operator == ( const Point &xPoint ) const
{
    bool isEquality = false;
    if( this->x == xPoint.x && this->y == xPoint.y )
    {
	isEquality = true;
    }
    return isEquality;
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

PointCollection.h

#pragma once

#include "Point.h"

const int MAXPoint = 100;

class PointCollection
{
private:
	Point pts[ MAXPoint ];
	int quantity;

public:
	PointCollection( void );
	PointCollection( const PointCollection &xPointCollection );
	~PointCollection( void );

	// To know how many Points are
	// ..in the collection
	int size() const; 

	PointCollection operator = ( const PointCollection &xPointCollection );

	PointCollection &operator + ( const Point &xPoint );
	
	Point &operator[]( int index );
	const Point &operator[]( int index ) const;

	bool isFull() const;
	bool isEmpty() const;

	bool includes( const Point &xPoint ) const;
	int indexOf( const Point &xPoint ) const;
};

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

PointCollection.cpp

#include "PointCollection.h"

PointCollection::PointCollection( void )
{
	this->quantity = 0;
}

PointCollection::PointCollection( const PointCollection &xPointCollection )
{
	this->quantity = xPointCollection.quantity;

	for ( int i = 0 ; i < this->quantity ; i++ )
		( this->pts )[ i ] = ( xPointCollection.pts )[ i ];
}

PointCollection::~PointCollection( void ) {}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

int PointCollection::size() const
{
	return ( this->quantity );
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

Point &PointCollection::operator []( int index )
{
	return ( ( this->pts )[ index ] );
}

const Point &PointCollection::operator []( int index ) const
{
	return ( ( this->pts )[ index ] );
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

PointCollection PointCollection::operator =( const PointCollection &xPointCollection )
{
	this->quantity = xPointCollection.quantity;

	for ( int i = 0 ; i < this->quantity ; i++ )
		( this->pts )[ i ] = ( xPointCollection.pts )[ i ];

	return ( *this );
}

PointCollection &PointCollection::operator +( const Point &xPoint )
{
	(*this)[ this->quantity ] = xPoint;

	(this->quantity)++;

	return ( *this );
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

bool PointCollection::isFull() const
{
	return ( this->quantity == MAXPoint );
}

bool PointCollection::isEmpty() const
{
	return ( this->quantity == 0 );
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

bool PointCollection::includes( const Point &xPoint ) const
{
	bool thisOne = false;

	for ( int i = 0 ; i < this->quantity && ! thisOne ; i++ )
	{
		if( pts[ i ] == xPoint )
			thisOne = true;
	}

	return ( thisOne );
}

int PointCollection::indexOf( const Point &xPoint ) const
{
	int index = -1;

	for ( int i = 0 ; i < this->quantity && index == -1 ; i++ )
	{
		if( pts[ i ] == xPoint )
			index = i;
	}

	return ( index );
}

Line.h

#pragma once

#include "Point.h"

class Linea
{
private:
	Point begin;
	Point end;

public:
	Linea( void );
	Linea( const Linea &xLinea );
	Linea( Point XY1, Point XY2 );
	~Linea( void );

	Linea &operator = ( const Linea &xLinea );

	bool includes( int cord_X, int cord_Y ) const;
	bool operator == ( const Linea &xLinea ) const;

	double m() const; // Pendiente
	double b() const; // Intercept in Y

	bool isVertical() const;
	bool isHorizontal() const;
	bool isDiagonal() const;

	void draw() const;
};

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

Line.cpp

#include "Linea.h"

Linea::Linea()
{
}

Linea::Linea( Point XY1, Point XY2 ) 
{
	this->begin = begin;
	this->end = end;
}

Linea::Linea( const Linea &xLinea )
{
	this->begin = xLinea.begin;
	this->end = xLinea.end;
}

Linea::~Linea( void )
{
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

Linea &Linea::operator =( const Linea &xLinea )
{
	if( this != &xLinea )
    {
		this->begin = xLinea.begin;
		this->end = xLinea.end;
    }

    return ( *this );
}

bool Linea::operator == ( const Linea &xLinea ) const
{
    bool isEquality = false;
    if( this->begin == xLinea.begin &&
		this->end == xLinea.end )
    {
	isEquality = true;
    }
    return isEquality;
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

double Linea::m()const
{
	return ( (this->end.getY()) - (this->begin.getY()) ) / ((this->end.getX()) - (this->begin.getX()) );
}

double Linea::b()const
{
	return ( this->end.getY() - (this->m() * this->end.getX()) );
}


bool Linea::isVertical () const
{
	return ( ( (this->end.getX()) - (this->begin.getX()) ) == 0 );
}

bool Linea::isHorizontal () const
{
	return ( ( (this->end.getY()) - (this->begin.getY()) ) == 0 );
}

bool Linea::isDiagonal () const
{
	return ( this->isVertical() && this->isHorizontal() );
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

bool Linea::includes( int cord_X, int cord_Y ) const
{
	bool included = false;

	if ( this->isHorizontal() )
	{
		if ( ( (this->begin).getY() == cord_Y ) && 

		     ( (this->begin).getX() <= cord_X ) &&

		     ( (this->end).getX() >= cord_X ) ||

		     ( (this->begin).getX() >= cord_X ) &&

		     ( (this->end).getX() <= cord_X ) )

				included = true;
	}

	else if ( this->isVertical() )
	{
		if ( ( (this->begin).getX() == cord_X ) && 

		     ( (this->begin).getY() <= cord_Y ) && 

		     ( (this->end).getY() >= cord_Y ) ||

		     ( (this->begin).getY() >= cord_Y ) && 
			 
			 ( (this->end).getY() <= cord_Y ) )

				included = true;
	}

	else
	{
		if ( ( cord_Y == this->m() * cord_X + this->b() ) && 

			( (this->begin).getX() <= cord_X ) && 
			
			( (this->end).getX() >= cord_X ) || 
			
			( (this->begin).getX() >= cord_X ) &&

			( (this->end).getY() >= cord_Y ) ||

			( (this->begin).getY() >= cord_Y ) &&

			( (this->end).getY() <= cord_Y ) )

				included = true;
	}

	return ( included );
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

void Linea::draw() const
{
	cout << '.';
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

LineCollectoin.h

#pragma once

#include "Linea.h"

const int MAX = 100;

class LineCollection
{
private:
	Linea lc[ MAX ];
	int quantity;

public:
	LineCollection(void);
	LineCollection( const LineCollection &xLineCollection );
	~LineCollection(void);

	// To know how many Lines are
	// ..in the collection
	int size() const;

	LineCollection operator = ( const LineCollection &xLineCollection );

	LineCollection &operator + ( const Linea &xLinea );

	Linea &operator [] ( int index );
	const Linea &operator[]( int index ) const;

	bool isFull() const;
	bool isEmpty() const;

	bool includes( const Linea &xLinea ) const;
	int indexOF( const Linea &xLinea ) const;

	friend ostream &operator << ( ostream &output, const LineCollection &xLineCollection );
	friend istream &operator >> ( istream &input, LineCollection &xLineCollection );
};

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

LineCollection.cpp

#include "LineCollection.h"

LineCollection::LineCollection( void )
{
	this->quantity = 0;
}

LineCollection::LineCollection( const LineCollection &xLineCollection )
{
	this->quantity = xLineCollection.quantity;

	for ( int i = 0 ; i < this->quantity ; i++ )
		( this->lc )[ i ] = ( xLineCollection.lc )[ i ];
}

LineCollection::~LineCollection( void ) {}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

int LineCollection::size() const
{
	return ( this->quantity );
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

Linea &LineCollection::operator []( int index )
{
	return ( ( this->lc )[ index ] );
}

const Linea &LineCollection::operator []( int index ) const
{
	return ( ( this->lc )[ index ] );
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

LineCollection LineCollection::operator =( const LineCollection &xLineCollection )
{
	this->quantity = xLineCollection.quantity;

	for ( int i = 0 ; i < this->quantity ; i++ )
		( this->lc )[ i ] = ( xLineCollection.lc )[ i ];

	return ( *this );
}

LineCollection &LineCollection::operator +( const Linea &xLinea ) 
{
	(*this)[ this->quantity ] = xLinea;
	(this->quantity)++;

	return ( *this );
}


/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

bool LineCollection::isFull() const
{
	return ( this->quantity == MAX );
}

bool LineCollection::isEmpty() const
{
	return ( this->quantity == 0 );
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////


bool LineCollection::includes(const Linea &xLinea) const
{
	bool thisOne = false;

	for ( int i = 0 ; i < this->quantity && ! thisOne ; i++ )
	{
		if ( lc == xLinea )
			thisOne = true;
	}
	return ( thisOne );
}

int LineCollection::indexOF( const Linea &xLinea ) const
{
	int index = -1;

	for ( int i = 0 ; i < this->quantity && index == -1 ; i++ )
	{
		if ( lc == xLinea )
			index = i;
	}

	return ( index );
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

Page.h

#pragma once

#include "PointCollection.h"
#include "LineCollection.h"

const int MAXPAGE = 100;

class Page
{
private:
	int heigh;
	int width;

public:
	Page( void );
	Page( int width, int heigh );
	Page( const Page &xPage );
	~Page( void );

	void setWidth( int width );
	int getWidth() const;

	void setHeigh( int heigh );
	int getHeigh() const;

	bool operator == ( const Page &xPage ) const;

	void draw() const;
};

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

Page.cpp

#include "Page.h"

Page::Page( void )
{
	this->width = 0;
	this->heigh = 0;
}

Page::Page( int width, int heigh )
{
	this->width = width;
	this->heigh = heigh;
}

Page::Page( const Page &xPage )
{
	this->width = xPage.width;
	this->heigh = xPage.heigh;
}

Page::~Page( void ) {}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

void Page::setHeigh( int heigh )
{
	this->heigh = heigh;
}

void Page::setWidth( int width )
{
	this->width = width;
}

int Page::getHeigh() const
{
	return ( this->heigh );
}

int Page::getWidth() const
{
	return ( this->width );
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

void Page::draw() const
{
	bool included;
	PointCollection pc;
	LineCollection li;

	for( int y = 0 ; y < this->heigh ; y++ )
	{
		included = false;

		for ( int x = 0; x < this->width ; x++ )
		{
			for ( int p = 0 ; p < pc.size()  && !included ; p++ )
			{

				if ( pc[ p ].includes( x, y ) )
				{
					pc[ p ].draw();
					included = true;
				}

				if ( included )
					cout << ' ';
			}

			for ( int line = 0 ; line < li.size()  && !included ; line++ )
			{

				if ( li[ line ].includes( x, y ) )
				{
					li[ line ].draw();
					included = true;
				}

				if ( included )
					cout << ' ';
			}

		}
		cout << endl;
	}
}

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

bool Page::operator ==( const Page &xPage ) const
{
	bool isEquality = false;

	if( this->heigh == xPage.heigh && this->width == xPage.width )
    {
		isEquality = true;
    }

    return isEquality;
}

Main.cpp

#include "Page.h"

int main ()
{
	
	Point p1( 5, 5 ), p2( 1, 1 );
	Linea L;
	Page pg( 15, 15 );

	p1.draw();

	pg.draw();

	/*
	if ( p1.includes( 1, 1 ) == true )
		cout << "Point 1 & 2 are Equal" << "\n\n";
	else
		cout << "Point 1 & 2 are NOT Equal" << "\n\n";
	*/

	system("PAUSE");
	return 0;

}

porter · December 21, 2007, 1:19pm

Whoah, whoah.

Don't shout we are not deaf.
I hope this is not homework, see rule 6.
You have given no clue to scenario, output device, formatting, protocol, input etc.

Can you start at the begining, please?

Max_Payne · December 21, 2007, 1:23pm

I made the program. But I'm stuck in the main().

This is not homework But i have been stuck trying to do this a week now.

When i print the dots or lines it just prints the dot in the draw() function not in the coordinate like it should be.

I just need i hint on how to do so.

porter · December 21, 2007, 1:26pm

As I said, 3. You have given no clue to scenario, output device, formatting, protocol, input etc.

What is it doing? Driving an HP plotter? Emitting postscript? Driving a Tektronics graphics terminal?

Max_Payne · December 21, 2007, 1:30pm

The Program is supposed to print a figure using dots, lines:

for example:

---------
|  .    . |
|    .    |
|  ---- |
---------

I made the necessary classes and collections to do so. But I don't know how to do that in the main function. I just need a hint.

porter · December 21, 2007, 1:44pm

Cool. So what is the output page, is it an array of characters?

I would do it by restricting yourself to drawing

(a) horizontal lines
(b) vertical line
(c) dots

When you draw a horizontal line, use the "-" character, when a vertical line use a "|", and when a dot use a ".". Have a coordinate system based on characters.

Max_Payne · December 21, 2007, 1:55pm

Actually it will print dots it should be more like this:


...............
.  .       .  .
.      .      .
.   .......   .
...............


                  .
                 .
                .
               .
              .
             .

I made the calculations needed to do so:

Depending on the coordinates the line would be printed. 

for example L( 1, 1 ) will print a Horizontal line of dots.

Did i make myself clear enough. I'm really having a hard time translating what i want.

I just don't know how to do that in the page ?

porter · December 21, 2007, 2:09pm

What representation are you using in Page to hold a page?

For this example I would have a page being an array of characters where each is initialised to a space. Then drawing is simply a matter of setting the appropriate character. Once all the drawing has been done you then emit the page to stdout.

Max_Payne · December 21, 2007, 2:11pm

Can you look at the code and give me an example ?

porter · December 21, 2007, 2:24pm

Your page, as far as I can see only has a width and a height.

No storage for the representation of the page itself.

class Page
{
.....
char *pagedata;

       Page(....)
       {
            pagedata=new char[width*height];
       }

       ~Page()
       {
            delete pagedata;
       }

       plot_character(int x,int y,char c)
       {
            pagedata[(y*width)+x]=c;
       }

       void print_page()
       {
             int y=0;
             char *p=pagedata;
             while (y < height)
             {
                   fwrite(p,width,1,stdout);
                   fprintf(fp,"\n");
                   y++;
                   p+=x;
             }
       }
};

Max_Payne · December 21, 2007, 3:46pm

Thanks................

Max_Payne · December 23, 2007, 1:30am

Still can't figure it out.

What do i put in the main() function that will let me print points and lines anywhere i want in the page ?

porter · December 23, 2007, 2:06am

How about have the main program reading in from stdin a load of text rows, where each row is a sequence of pairs of coordianets describing a path.

Then read the textual representation and create

(a) a page

(b) a series of point collections where each list of points is a path

when you read EOF then render the page into the sequence of characters and print out on stdout.