### Home Classes Methods

### In Files

- lib/geometry.rb

### Parent

Object

### Methods

- ::new
- #<
- #==
- #clone
- #coincident?
- #collinear?
- #hash
- #head=
- #length
- #overlap?
- #tail=

### Files

- LessThan5BlueLabels.txt
- AtLeast2LargeSegments.txt

### Class Index

Quicksearch

- AddLabelTool
- AllRulesAppliedGoal
- Area
- AreaConstraint
- Array
- BalancedBinaryTree
- BalancedBinaryTreeNode
- CloseObserver
- Constants
- Constraint
- CurrentLabelledShape
- DistinctShapeConstraint
- Execution
- Goal
- Grammar
- Label
- LabelledShape
- LineDescriptor
- LinearLinkedList
- LinearLinkedListNode
- NoLabelsGoal
- NoMoreRulesGoal
- NoScalesConstraint
- Numeric
- Object
- OrderedPoint
- PiList
- Point
- Project
- Robot
- Rule
- RuleGroupsObserver
- RuleLabelledShape
- RuleShapeObserver
- Segment
- ShaDeLayersObserver
- Shade
- ShadeUtils
- UndoObserver

No matching classes.

# Segment

Author | Manuela Ruiz (mruiz@lcc.uma.es)

This class represents a segment, with its end points

### Attributes

tail[R]

An OrderedPoint for the tail (the smaller point) of the segment

head[R]

An OrderedPoint for the head (the bigger point) of the segment

line_descriptor[R]

A LineDescriptor object for the line on which the segment lies

### Public Class Methods

new(tail, head) click to toggle source

tail | the first point of the segment
head | the second point of the segment

Initialize the segment, ordering the tail and head propertly, so tail < head

         # File lib/geometry.rb, line 302
    302:         def initialize(tail, head)

    303:                 #Order the tail and head

    304:                 if tail < head

    305:                         @tail = tail

    306:                         @head = head

    307:                 else

    308:                         @tail = head

    309:                         @head = tail

    310:                 end

    311:

    312:                 #Compute the line descriptor

    313:                 if (@tail.x - @head.x).abs < Constants::EPSILON #Vertical

    314:                         sine = 1

    315:                         intercept = @tail.x

    316:                 elsif (@tail.y - @head.y).abs <  Constants::EPSILON #Horizontal

    317:                         sine = 0

    318:                         intercept = @tail.y

    319:                 else

    320:                         sine = ((@head.y - @tail.y) / Math.sqrt(((@head.x - @tail.x)**2 )+((@head.y - @tail.y)**2)))

    321:                         if ((@head.x - @tail.x) > 0)

    322:                                 den = Math.sqrt((@head.x - @tail.x)**2)

    323:                         else

    324:                                 den = 1 * Math.sqrt((@head.x - @tail.x)**2)

    325:                         end

    326:                         if ((@head.y - @tail.y) > 0)

    327:                                 mult = Math.sqrt((@head.y - @tail.y)**2)

    328:                         else

    329:                                 mult = 1 * Math.sqrt((@head.y - @tail.y)**2)

    330:                         end

    331:                         intercept = (1*@tail.x/den)*(mult) + @tail.y

    332:                 end

    333:                 @line_descriptor = LineDescriptor.new(sine, intercept)

    334:         end

### Public Instance Methods

<(other_segment) click to toggle source

other_segment | another segment
returns | true iff this segment is lesser than other_segment. Only collinear segments can be compared.

A segment A is lesser than a segment B iff the head of A is smaller than the tail of B.

         # File lib/geometry.rb, line 459
    459:         def < (other_segment)

    460:                 raise ArgumentError, 'The argument is not of type Segment' unless other_segment.kind_of? Segment

    461:                 #raise ArgumentError, 'Segments are not collinear' unless collinear?(other_segment)

    462:                 return @head < other_segment.tail

    463:         end

==(other_segment) click to toggle source

other_segment | another segment
returns | true iff this segment is equal to other_segment. Only collinear segments can be compared.

         # File lib/geometry.rb, line 468
    468:         def == (other_segment)

    469:                 result = false

    470:                 if other_segment.kind_of? Segment

    471:                         result = ((@head == other_segment.head) && (@tail == other_segment.tail))

    472:                 end

    473:                 return result

    474:         end

clone() click to toggle source

returns | a new Segment object, identical to this one

         # File lib/geometry.rb, line 477
    477:         def clone()

    478:                 return Segment.new(@tail.clone, @head.clone)

    479:         end

coincident?(point) click to toggle source

point | a point
returns | true iff the point is coincident with the segment, that is, is ‘inside’ the segment

         # File lib/geometry.rb, line 411
    411:         def coincident?(point)

    412:                 result = false

    413:

    414:                 if (point == @tail) || (point == @head)

    415:                         result = true

    416:                 elsif (@line_descriptor.satisfied? point) && (@tail < point) && (point < @head)

    417:                         result = true

    418:                 end

    419:

    420:                 return result

    421:         end

collinear?(other_segment) click to toggle source

other_segment | another segment
returns | true iff both line descriptors are equal, that is, both segments share the same ‘mother line’

         # File lib/geometry.rb, line 450
    450:         def collinear?(other_segment)

    451:                 raise ArgumentError, 'The argument is not of type Segment' unless other_segment.kind_of? Segment

    452:                 return @line_descriptor == other_segment.line_descriptor

    453:         end

hash() click to toggle source

returns | the hash code for this segment

         # File lib/geometry.rb, line 482
    482:         def hash

    483:                 return [@line_descriptor.hash, @tail.hash, @head.hash].hash

    484:         end

head=(new_head) click to toggle source

new_head | an OrderedPoint

Sets the head to new_head

         # File lib/geometry.rb, line 375
    375:         def head=(new_head)

    376:                 #Order the tail and head

    377:                 if @tail < new_head

    378:                         @head = new_head

    379:                 else

    380:                         @head = @tail

    381:                         @tail = new_head

    382:                 end

    383:

    384:                 #Compute the line descriptor

    385:                 if (@tail.x - @head.x).abs < Constants::EPSILON #Vertical

    386:                         sine = 1

    387:                         intercept = @tail.x

    388:                 elsif (@tail.y - @head.y).abs < Constants::EPSILON #Horizontal

    389:                         sine = 0

    390:                         intercept = @tail.y

    391:                 else

    392:                         sine = ((@head.y - @tail.y) / Math.sqrt(((@head.x - @tail.x)**2)+((@head.y - @tail.y)**2)))

    393:                         if ((@head.x - @tail.x) > 0)

    394:                                 den = Math.sqrt((@head.x - @tail.x)**2)

    395:                         else

    396:                                 den = 1 * Math.sqrt((@head.x - @tail.x)**2)

    397:                         end

    398:                         if ((@head.y - @tail.y) > 0)

    399:                                 mult = Math.sqrt((@head.y - @tail.y)**2)

    400:                         else

    401:                                 mult = 1 * Math.sqrt((@head.y - @tail.y)**2)

    402:                         end

    403:                         intercept = (1*@tail.x/den)*(mult) + @tail.y

    404:                 end

    405:                 @line_descriptor = LineDescriptor.new(sine, intercept)

    406:         end

length() click to toggle source

returns | the distance between the tail and the head of this segment

         # File lib/geometry.rb, line 487
    487:         def length

    488:                 return @tail.point.distance(@head.point)

    489:         end

overlap?(other_segment) click to toggle source

other_segment | another segment
returns | the resulting segment in case the two segments overlap.

         # File lib/geometry.rb, line 426
    426:         def overlap?(other_segment)

    427:                 raise ArgumentError, 'The argument is not of type Segment' unless other_segment.kind_of? Segment

    428:                 result = nil

    429:                 if collinear?(other_segment)

    430:                         if (@tail < other_segment.head) && (other_segment.tail < @head)

    431:                                 new_tail = @tail

    432:                                 if @tail < other_segment.tail

    433:                                         new_tail = other_segment.tail

    434:                                 end

    435:

    436:                                 new_head = @head

    437:                                 if other_segment.head < @head

    438:                                         new_head = other_segment.head

    439:                                 end

    440:

    441:                                 result = Segment.new(new_tail, new_head)

    442:                         end

    443:                 end

    444:                 return result

    445:         end

tail=(new_tail) click to toggle source

new_tail | an OrderedPoint

Sets the tail to new_tail

         # File lib/geometry.rb, line 339
    339:         def tail=(new_tail)

    340:                 #Order the tail and head

    341:                 if new_tail < @head

    342:                         @tail = new_tail

    343:                 else

    344:                         @tail = @head

    345:                         @head = new_tail

    346:                 end

    347:

    348:                 #Compute the line descriptor

    349:                 if (@tail.x - @head.x).abs < Constants::EPSILON #Vertical

    350:                         sine = 1

    351:                         intercept = @tail.x

    352:                 elsif (@tail.y - @head.y).abs <  Constants::EPSILON#Horizontal

    353:                         sine = 0

    354:                         intercept = @tail.y

    355:                 else

    356:                         sine = ((@head.y - @tail.y) / Math.sqrt(((@head.x - @tail.x)**2 )+((@head.y - @tail.y)**2)))

    357:                         if ((@head.x - @tail.x) > 0)

    358:                                 den = Math.sqrt((@head.x - @tail.x)**2)

    359:                         else

    360:                                 den = 1 * Math.sqrt((@head.x - @tail.x)**2)

    361:                         end

    362:                         if ((@head.y - @tail.y) > 0)

    363:                                 mult = Math.sqrt((@head.y - @tail.y)**2)

    364:                         else

    365:                                 mult = 1 * Math.sqrt((@head.y - @tail.y)**2)

    366:                         end

    367:                         intercept = (1*@tail.x/den)*(mult) + @tail.y

    368:                 end

    369:                 @line_descriptor = LineDescriptor.new(sine, intercept)

    370:         end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.