The UNIX and Linux Forums  
Hello and Welcome from United States to the UNIX and Linux Forums! Thank You for Visiting and Joining Our Global Community.

Go Back   The UNIX and Linux Forums > Top Forums > High Level Programming
[ C++ ] Drawing Program. [ C++ ] Drawing Program.
.
google unix.com

Forums Register Forum RulesLinksAlbums FAQ Members List Calendar Search Today's Posts Mark Forums Read


High Level Programming Post questions about C, C++, Java, SQL, and other programming languages here.

More UNIX and Linux Forum Topics You Might Find Helpful
Thread Thread Starter Forum Replies Last Post
A program to trace execution of another program jiten_hegde High Level Programming 3 08-19-2008 06:26 AM
How to write to stdin of another program (program A -> [stdin]program B) vvaidyan High Level Programming 1 04-30-2008 02:44 PM
Still Time Today to Join the $5000 AJAXWorld Drawing - SYS-CON Media iBot UNIX and Linux RSS News 0 08-24-2007 11:50 AM
Drawing abrd600 Shell Programming and Scripting 3 08-23-2005 12:38 PM
Line-drawing character! zecoj High Level Programming 5 03-10-2002 11:38 AM

 
English Japanese Spanish French German Portuguese Italian Dutch Swedish Russian Norwegian Hungarian Hebrew Danish Bulgarian Greek Powered by Powered by Google
 
LinkBack Thread Tools Search this Thread Rate Thread Display Modes
Prev Previous Post   Next Post Next
  #1 (permalink)  
Old 12-21-2007
Max_Payne's Avatar
Max_Payne Max_Payne is offline
Registered User
  
 

Join Date: Dec 2007
Posts: 8
[ C++ ] Drawing Program.
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

Code:
#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

Code:
#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

Code:
#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

Code:
#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

Code:
#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

Code:
#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

Code:
#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

Code:
#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[i] == 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[i] == xLinea )
			index = i;
	}

	return ( index );
}
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

Page.h

Code:
#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

Code:
#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

Code:
#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;

}
Last edited by Max_Payne; 12-21-2007 at 03:17 PM..
 

Bookmarks

« RS-232 C++ Programming | Creating a Hash Table »
Thread Tools Search this Thread
Search this Thread:

Advanced Search
Display Modes Rate This Thread
Threaded Mode Threaded Mode
Rate This Thread:

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts
BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are On



All times are GMT -4. The time now is 02:14 AM.

The UNIX and Linux Forums - Learn UNIX and UNIX Commands RSS Feeds - Contact Us - The UNIX and Linux Forums - Learn UNIX and UNIX Commands - Archive - Top

Powered by: vBulletin, Copyright ©2000 - 2006, Jelsoft Enterprises Limited. Language Translations Powered by .
vBCredits v1.4 Copyright ©2007 - 2008, PixelFX Studios
The UNIX and Linux Forums Content Copyright ©1993-2009. All Rights Reserved.Ad Management by RedTyger

Content Relevant URLs by vBSEO 3.2.0