Exercise 8-6 Kochan 2.0

Discussion in 'Mac Programming' started by mdeh, Jan 16, 2009.

  1. mdeh macrumors 6502

    Joined:
    Jan 3, 2009
    #1
    Write a Rectangle method called intersect: that takes a rectangle as an argument and returns a rectangle representing the overlapping area between the two rectangles. So, for example, given the two rectangles shown in Figure 8.9, the method should return a rectangle whose origin is at (400, 380), whose width is 50, and whose height is 60.



    Rectangle.h

    Code:
    #import <Foundation/Foundation.h>
    #import "XYPoint.h"
    
    @interface Rectangle : NSObject {
    	int height;
    	int width;
    	XYPoint *origin;
    	}
    @property int height, width;
    
    /* setters */
    
    -(XYPoint *) origin;
    
    -(void) SetOrigin: (XYPoint *) pt;
    
    -(void) setWidth: (int) w andHeight: ( int) h;
    
    /* utility */
    
    -(void) dealloc;
    
    -(int) area;
    -(int) perimeter;
    
    -(Rectangle *) intersect: (Rectangle *) myRect;
    
    -(BOOL) rectangleIntersectsWith: (Rectangle *) theRect;
    
    @end
    
    rectangle.m

    Code:
    #import "Rectangle.h"
    
    
    
    @implementation Rectangle
    
    @synthesize width, height;
    
    
    -(void) SetOrigin: (XYPoint *) pt
    {
    	if (origin)
    		[origin release];
    	
    	origin = [[ XYPoint alloc] init] ;
    	[origin setX: pt.x andY: pt.y];
    }
    
    
    -(XYPoint *) origin
    {
    	return origin;
    }
    
    
    -(int) area
    {
    	return width * height;
    }
    
    -(int) perimeter
    {
    	return 2 * ( width + height );
    }
    
    -(void) setWidth: (int) w andHeight: ( int) h
    {
    	width = w;
    	height = h;
    }
    
    -(Rectangle *) intersect: (Rectangle *) myRect
    {
    	BOOL overLap;
    	BOOL argumentISLower = NO;
    	
    	Rectangle *returnRect = [[Rectangle alloc] init];
    	XYPoint *retPt = [ [ XYPoint alloc ] init];
    	
    	
    	overLap = [self rectangleIntersectsWith: myRect];
    	argumentISLower = origin. y > myRect.origin.y;
    
    		
    	
    	if (overLap == NO)
    	{
    	returnRect.origin.x = 0;
    	returnRect.origin.y = 0;
    	returnRect.width = 0;
    	returnRect.height = 0;
    	}
    
    	else
    		
    	{
    		
    	retPt.x	= (myRect.origin.x > origin.x ) ? myRect.origin.x : origin.x;
    	retPt.y  = origin.y;
    	[returnRect SetOrigin: retPt];
    	returnRect.height =  (argumentISLower == YES) ? myRect.origin.y + myRect.height - origin.y : origin.y \
    	+ height - myRect.origin.y;
    	returnRect.width  = (myRect.origin.x > origin.x) ? origin.x + width - myRect.origin.x : myRect.origin.x \
    	+ myRect.width - origin.x;
    	}
    	
    	[retPt release];
    	
    	return returnRect;
    	}
    
    -(BOOL) rectangleIntersectsWith: (Rectangle *) theRect
    {
    	
    	
    	/* one rectangle is above or below the other */
    	if ( origin.y > theRect.origin.y + theRect.height || origin.y + height < theRect.origin.y)
    		return NO;
    	
    	/* one rectangle is either to the left or right */
    	if ( origin.x + width < theRect.origin.x || theRect.origin.x + width < origin.x)
    		return NO;
    	
    	return YES;  /* all other conditions should  overlap */
    }
    
    
    -(void) dealloc
    {
    	
    	[origin release];
    	[super dealloc];
    }
    
    
    
    @end
    

    XYPoint.h

    Code:
    #import <Foundation/Foundation.h>
    
    
    @interface XYPoint : NSObject {
    	int x;
    	int y;
    }
    
    @property int x, y;
    
    -(void) setX: (int) xVal andY: (int) yVal;
    
    @end
    

    XYPoint.m

    Code:
    #import "XYPoint.h"
    
    
    @implementation XYPoint
    
    @synthesize x, y;
    
    -(void) setX: (int) xVal andY: (int) yVal
    {
    	x = xVal;
    	y = yVal;
    }
    
    
    @end
    

    main.h

    Code:
    #import "Rectangle.h"
    #import "XYPoint.h"
    
    int main (int argc, const char * argv[]) {
        NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    	Rectangle *resRectangle;
    	Rectangle * rect1 = [[ Rectangle alloc] init];
    	Rectangle * rect2 = [ [ Rectangle alloc] init];
    	XYPoint *myPt1 = [ [ XYPoint alloc] init];
    	XYPoint *myPt2 = [ [ XYPoint alloc] init];
    	
    	myPt1.x = 200;
    	rect1.height = 75;
    	rect1.width = 250;
    	
    	
    	rect2.width = 100;
    	rect2.height = 180;
    	myPt2.x = 150;
    	myPt2.y = 300;
    	[rect2 SetOrigin: myPt2 ];
    	
    	for (myPt1.y = 200; myPt1.y <= 500; myPt1.y ++){
    	[rect1 SetOrigin: myPt1];
    	resRectangle = [rect1 intersect: rect2 ];
    	NSLog(@" New rectangle: {Pt(%3i,%3i)} Width(%-2i), Height(%-3i), Origin(%3i,%3i)", myPt1.x, myPt1.y, resRectangle.width, resRectangle.height,\
    		  resRectangle.origin.x, resRectangle.origin.y);
    [resRectangle release];
    	}
    	
    	[rect1 release];
    	[rect2 release];
    	[myPt1 release];
    	[myPt2 release];
    	
       
        [pool drain];
        return 0;
    }
    


    Look forward to anyone's input.
     
  2. TotalLuck macrumors newbie

    TotalLuck

    Joined:
    Jan 3, 2009
    Location:
    Moreno Vallley
    #2
    Here was what i got.

    Hey Mdeh,
    you went way deeper than i did and now i need to relook at my code. thanks for posting that. I'm posting what i wrote just for kicks and mockery.

    Rectangle.m
    Code:
    -(Rectangle *) intersect: (Rectangle *) bRect
    {
    	Rectangle *overlapRect = [[ Rectangle alloc] init];
    	XYpoint *overlapPT = [[ XYpoint alloc] init];
    	
    	overlapRect.height = self.origin.y - bRect.origin.y - bRect.height;
    	if (overlapRect.height <= 0) 
    		overlapRect.height *= -1;
    	
    	overlapRect.width = self.width - bRect.origin.y;
    	if (overlapRect.width <= 0)
    		overlapRect.width *= -1;
    	
    	[overlapPT setX: bRect.origin.x andY:self.origin.y];
    	[overlapRect setOrigin: overlapPT];
    	
    	NSLog(@"The Intersect Rectangle  is  %gw x %gh with origin at %g,%g", overlapRect.width, overlapRect.height, overlapPT.x, overlapPT.y);
    
    	[overlapPT release];
    	[overlapRect release];
    	return 0;
    }
    
    rectangle.h
    Code:
    @interface Rectangle : GraphicObject
    {
    	double width;
    	double height;
    	XYpoint *origin;
    }
    
    @property double  width, height;
    
    -(XYpoint *) origin;
    -(void) setOrigin: (XYpoint *) pt;
    -(double) area;
    -(double) perimiter;
    -(void) setwidth: (double) w andheight: (double) h;
    -(XYpoint *) translate: (XYpoint *) mypt; 
    -(void) draw;
    -(Rectangle *) intersect: (Rectangle *) bRect;
    @end
    
    Main.m
    Code:
    int main(int argc, char *argv[])
    {
    	NSAutoreleasePool * pool = [[NSAutoreleasePool alloc]init];
    	Rectangle *rectA = [[ Rectangle alloc] init];
    	Rectangle *rectB = [[ Rectangle alloc] init];
    	XYpoint *rectAPT = [[ XYpoint alloc] init];
    	XYpoint *rectBPT = [[ XYpoint alloc] init];
    
    	
    	[rectAPT setX:200 andY: 420];
    	[rectA setwidth:250 andheight:75];
    	[rectA setOrigin: rectAPT];
    	
    	NSLog(@"Rectangle A  is  %gw x %gh with origin at %g,%g", rectA.width, rectA.height, rectA.origin.x, rectA.origin.y);
    
    	[rectBPT setX:400	andY:300];
    	[rectB	setwidth:100 andheight:180 ];
    	[rectB	setOrigin: rectBPT];
    	
    	NSLog(@"Rectangle B  is  %gw x %gh with origin at %g,%g", rectB.width, rectB.height, rectB.origin.x, rectB.origin.y);
    	
    	[rectA intersect: rectB];
    	
    	[rectB release];
    	[rectA release];
    	[rectBPT release];
    	[rectAPT release];
    
    	
    	return 0;
    	[pool release];
    	
    }
    my result:
    Rectangle A is 250w x 75h with origin at 200,420
    Rectangle B is 100w x 180h with origin at 400,300
    The Intersect Rectangle is 50w x 60h with origin at 400,420


    ***ok I didnt red the part at the bottom where it said to return a 0,0 for origin and 0 for w and h if they dont intersect. DUH
     

Share This Page