In Files

Parent

ShadeUtils

Author

Manuela Ruiz (mruiz@lcc.uma.es)

Utils class

Public Class Methods

add_cg_names() click to toggle source

Adds the default constraint and goals

      # File lib/utils.rb, line 1288
1288:         def ShadeUtils.add_cg_names()

1289:                 #Set list of constraint names and classes

1290:                 Shade.constraint_class_names = Array.new

1291:                 Shade.add_constraint_class_name [ DistinctShapeConstraint, Constants::DISTINCT_SHAPE_CONSTRAINT_NAME] 

1292:                 Shade.add_constraint_class_name [ NoScalesConstraint, Constants::NO_SCALES_CONSTRAINT_NAME] 

1293:                 Shade.add_constraint_class_name [ AreaConstraint, Constants::AREA_CONSTRAINT_NAME] 

1294:                 

1295:                 #Set list of goals names and classes

1296:                 Shade.goal_class_names = Array.new

1297:                 Shade.add_goal_class_name([NoLabelsGoal, Constants::NO_LABELS_GOAL_NAME])

1298:                 Shade.add_goal_class_name([AllRulesAppliedGoal, Constants::ALL_RULES_APPLIED_GOAL_NAME])

1299:                 Shade.add_goal_class_name([NoMoreRulesGoal, Constants::NO_MORE_RULES_GOAL_NAME])

1300:         end
ask_to_save_project() click to toggle source

Shows a dialog for saving the project

     # File lib/utils.rb, line 420
420:         def ShadeUtils.ask_to_save_project()

421:                 if Shade.using_sketchup

422:                         project = Shade.project

423:                         if !project.saved

424:                                 input = UI.messagebox("Save current project?", MB_YESNO)

425:                                 if input == 6

426:                                         if project.path

427:                                                 project.save(project.path, true)

428:                                                 project.saved = true

429:                                         else

430:                                                 path_to_save_to = UI.savepanel "Save Project", "", "project.prj"

431:                                                 if path_to_save_to

432:                                                         project.save(path_to_save_to, true)

433:                                                 end

434:                                                 project.saved = true

435:                                         end

436:                                 end

437:                                 

438:                         end

439:                 end

440:         end
axiom() click to toggle source
returns

the axiom

      # File lib/utils.rb, line 1179
1179:         def ShadeUtils.axiom()

1180:                 return Shade.project.execution.grammar.axiom

1181:         end
copy_shape(origin_rule_idx, origin_rule_part, destiny_rule_idx, destiny_rule_part) click to toggle source

origin_rule_idx: index of the origin rule origin_rule_part: Constants::LEFT or Constants::RIGHT destiny_rule_idx: index of the destiny rule. If -1, we refer to the axiom (that is, the shape is going to be copied to the axiom) destiny_rule_part: “Left”, “Right”, “Additive” or “” in case we refer to the axiom

Copies the origin shape (the one in the specified part of the specified rule) to the specified destiny Maintains the old transformations

     # File lib/utils.rb, line 755
755:         def ShadeUtils.copy_shape(origin_rule_idx, origin_rule_part, destiny_rule_idx, destiny_rule_part)

756:                 execution = Shade.project.execution

757:                 origin_rule = execution.grammar.rules[origin_rule_idx]

758:                 destiny_rule = execution.grammar.rules[destiny_rule_idx]

759:                 

760:                 if origin_rule_part == Constants::LEFT

761:                         origin_shape = origin_rule.left

762:                 elsif origin_rule_part == Constants::RIGHT

763:                         origin_shape = origin_rule.right

764:                 end

765:                 

766:                 new_shape = origin_shape.clone

767:                 new_shape.host_rule_id = destiny_rule.rule_id

768:                 new_shape.host_rule_part = destiny_rule_part

769:                 

770:                 if Shade.using_sketchup

771:                         if destiny_rule_part == Constants::LEFT

772:                                 Sketchup.active_model.layers.each { |layer|

773:                                         shape_transformation = destiny_rule.alpha.shape_transformation[layer.name]

774:                                         layout_transformation = destiny_rule.alpha.layout_transformation

775:                                         destiny_rule.alpha.erase

776:                                         destiny_rule.alpha = new_shape

777:                                         destiny_rule.alpha.shape_transformation[layer.name]= shape_transformation

778:                                         destiny_rule.alpha.layout_transformation = layout_transformation

779:                                 }

780:                         elsif destiny_rule_part == Constants::RIGHT

781:                                 Sketchup.active_model.layers.each { |layer|

782:                                         shape_transformation = destiny_rule.beta.shape_transformation[layer.name]

783:                                         layout_transformation = destiny_rule.beta.layout_transformation

784:                                         destiny_rule.beta.erase

785:                                         destiny_rule.beta = new_shape

786:                                         destiny_rule.beta.shape_transformation[layer.name] = shape_transformation

787:                                         destiny_rule.beta.layout_transformation = layout_transformation

788:                                 }

789:                         end

790:                 else

791:                         if destiny_rule_part == Constants::LEFT

792:                                 destiny_rule.alpha.erase

793:                                 destiny_rule.alpha = new_shape

794:                         elsif destiny_rule_part == Constants::RIGHT

795:                                 destiny_rule.beta.erase

796:                                 destiny_rule.beta = new_shape

797:                         end

798:                 end

799:                                 

800:                 execution.grammar.saved = false

801:         end
create_default_axiom() click to toggle source
returns

a default axiom

     # File lib/utils.rb, line 443
443:         def ShadeUtils.create_default_axiom()

444:                 axiom = LabelledShape.new(Array.new, Array.new)

445:                 segments = Array.new

446:                 segments[0] = Segment.new(OrderedPoint.new(Constants::PTS_1[0].clone), OrderedPoint.new(Constants::PTS_1[1].clone))

447:                 segments[1] = Segment.new(OrderedPoint.new(Constants::PTS_1[1].clone), OrderedPoint.new(Constants::PTS_1[2].clone))

448:                 segments[2] = Segment.new(OrderedPoint.new(Constants::PTS_1[2].clone), OrderedPoint.new(Constants::PTS_1[3].clone))

449:                 segments[3] = Segment.new(OrderedPoint.new(Constants::PTS_1[3].clone), OrderedPoint.new(Constants::PTS_1[0].clone))

450:                 

451:                 if Shade.using_sketchup

452:                         Sketchup.active_model.layers.each { |layer|

453:                                 segments.each { |segment|

454:                                         segment_list = LinearLinkedList.new

455: 

456:                                         node = LinearLinkedListNode.new(segment.line_descriptor.clone, segment_list, nil)

457:                                         

458:                                         inserted_node = axiom.s[layer.name].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

459:                                         segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

460:                                         inserted_node.list.insert_node(segment_node)

461:                                 }

462:                                 

463:                                 Constants::PTS_1.each {|point|

464:                                         label = Label.new(Constants::INTERSECTION_LABEL)

465:                                         point_list = LinearLinkedList.new

466:                                         

467:                                         node = LinearLinkedListNode.new(label, point_list, nil)

468:                                         

469:                                         inserted_node = axiom.p[layer.name].insert_node(node) #Insert the node corresponding to the label of the point

470:                                 

471:                                         point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

472:                                         inserted_node.list.insert_node(point_node) #Insert the point node

473:                                 }

474:                         }

475:                 else

476:                         segments.each { |segment|

477:                                 segment_list = LinearLinkedList.new

478: 

479:                                 node = LinearLinkedListNode.new(segment.line_descriptor.clone, segment_list, nil)

480:                                 

481:                                 inserted_node = axiom.s["Layer0"].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

482:                                 segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

483:                                 inserted_node.list.insert_node(segment_node)

484:                         }

485:                         

486:                         Constants::PTS_1.each {|point|

487:                                 label = Label.new(Constants::INTERSECTION_LABEL)

488:                                 point_list = LinearLinkedList.new

489:                                 

490:                                 node = LinearLinkedListNode.new(label, point_list, nil)

491:                                 

492:                                 inserted_node = axiom.p["Layer0"].insert_node(node) #Insert the node corresponding to the label of the point

493:                         

494:                                 point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

495:                                 inserted_node.list.insert_node(point_node) #Insert the point node

496:                         }

497:                 end

498:                 return axiom

499:         end
create_default_current_shape() click to toggle source
returns

a default current shape

     # File lib/utils.rb, line 503
503:         def ShadeUtils.create_default_current_shape()

504:                 current_shape = CurrentLabelledShape.new(Array.new, Array.new)

505:                 segments = Array.new

506:                 segments[0] = Segment.new(OrderedPoint.new(Constants::PTS_1[0].clone), OrderedPoint.new(Constants::PTS_1[1].clone))

507:                 segments[1] = Segment.new(OrderedPoint.new(Constants::PTS_1[1].clone), OrderedPoint.new(Constants::PTS_1[2].clone))

508:                 segments[2] = Segment.new(OrderedPoint.new(Constants::PTS_1[2].clone), OrderedPoint.new(Constants::PTS_1[3].clone))

509:                 segments[3] = Segment.new(OrderedPoint.new(Constants::PTS_1[3].clone), OrderedPoint.new(Constants::PTS_1[0].clone))

510:                 

511:                 if Shade.using_sketchup

512:                         Sketchup.active_model.layers.each { |layer|

513:                                 segments.each { |segment|

514:                                         segment_list = LinearLinkedList.new

515: 

516:                                         node = BalancedBinaryTreeNode.new(0, nil, nil, segment.line_descriptor.clone, segment_list)

517:                                         

518:                                         inserted_node = current_shape.s[layer.name].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

519:                                         segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

520:                                         inserted_node.list.insert_node(segment_node)

521:                                 }

522:                                 

523:                                 

524:                                 Constants::PTS_1.each {|point|

525:                                         label = Label.new(Constants::INTERSECTION_LABEL)

526:                                         point_list = LinearLinkedList.new

527:                                         

528:                                         node = LinearLinkedListNode.new(label, point_list, nil)

529:                                         

530:                                         inserted_node = current_shape.p[layer.name].insert_node(node) #Insert the node corresponding to the label of the point

531:                                 

532:                                         point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

533:                                         inserted_node.list.insert_node(point_node) #Insert the point node

534:                                 }

535:                         }

536:                 else

537:                         segments.each { |segment|

538:                                 segment_list = LinearLinkedList.new

539: 

540:                                 node = BalancedBinaryTreeNode.new(0, nil, nil, segment.line_descriptor.clone, segment_list)

541:                                 

542:                                 inserted_node = current_shape.s["Layer0"].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

543:                                 segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

544:                                 inserted_node.list.insert_node(segment_node)

545:                         }

546:                         

547:                         

548:                         Constants::PTS_1.each {|point|

549:                                 label = Label.new(Constants::INTERSECTION_LABEL)

550:                                 point_list = LinearLinkedList.new

551:                                 

552:                                 node = LinearLinkedListNode.new(label, point_list, nil)

553:                                 

554:                                 inserted_node = current_shape.p["Layer0"].insert_node(node) #Insert the node corresponding to the label of the point

555:                         

556:                                 point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

557:                                 inserted_node.list.insert_node(point_node) #Insert the point node

558:                         }

559:                 end

560:                 current_shape.create_pi

561:                 return current_shape

562:         end
create_default_left_shape() click to toggle source
returns

a default left shape for the rules

     # File lib/utils.rb, line 565
565:         def ShadeUtils.create_default_left_shape()

566:                 shape = RuleLabelledShape.new(Array.new, Array.new, nil, nil)

567:                 segments = Array.new

568:                 segments[0] = Segment.new(OrderedPoint.new(Constants::PTS_1[0].clone), OrderedPoint.new(Constants::PTS_1[1].clone))

569:                 segments[1] = Segment.new(OrderedPoint.new(Constants::PTS_1[1].clone), OrderedPoint.new(Constants::PTS_1[2].clone))

570:                 segments[2] = Segment.new(OrderedPoint.new(Constants::PTS_1[2].clone), OrderedPoint.new(Constants::PTS_1[3].clone))

571:                 segments[3] = Segment.new(OrderedPoint.new(Constants::PTS_1[3].clone), OrderedPoint.new(Constants::PTS_1[0].clone))

572:                 

573:                 if Shade.using_sketchup

574:                         Sketchup.active_model.layers.each { |layer|

575:                                 segments.each { |segment|

576:                                         segment_list = LinearLinkedList.new

577: 

578:                                         node = LinearLinkedListNode.new(segment.line_descriptor.clone, segment_list, nil)

579:                                         

580:                                         inserted_node = shape.s[layer.name].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

581:                                         segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

582:                                         inserted_node.list.insert_node(segment_node)

583:                                 }

584: 

585:                                 Constants::PTS_1.each {|point|

586:                                         label = Label.new(Constants::INTERSECTION_LABEL)

587:                                         point_list = LinearLinkedList.new

588:                                         

589:                                         node = LinearLinkedListNode.new(label, point_list, nil)

590:                                         

591:                                         inserted_node = shape.p[layer.name].insert_node(node) #Insert the node corresponding to the label of the point

592:                                 

593:                                         point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

594:                                         inserted_node.list.insert_node(point_node) #Insert the point node

595:                                 }

596:                         }

597:                         shape.changed = true

598:                 else

599:                         segments.each { |segment|

600:                                 segment_list = LinearLinkedList.new

601: 

602:                                 node = LinearLinkedListNode.new(segment.line_descriptor.clone, segment_list, nil)

603:                                 

604:                                 inserted_node = shape.s["Layer0"].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

605:                                 segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

606:                                 inserted_node.list.insert_node(segment_node)

607:                         }

608: 

609:                         Constants::PTS_1.each {|point|

610:                                 label = Label.new(Constants::INTERSECTION_LABEL)

611:                                 point_list = LinearLinkedList.new

612:                                 

613:                                 node = LinearLinkedListNode.new(label, point_list, nil)

614:                                 

615:                                 inserted_node = shape.p["Layer0"].insert_node(node) #Insert the node corresponding to the label of the point

616:                         

617:                                 point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

618:                                 inserted_node.list.insert_node(point_node) #Insert the point node

619:                         }

620:                 end

621:                 return shape

622:         end
create_default_new_grammar() click to toggle source

Creates and loads a default grammar

     # File lib/utils.rb, line 805
805:         def ShadeUtils.create_default_new_grammar

806:                 execution = Shade.project.execution

807:                 rules = execution.grammar.rules

808:                 

809:                 size = rules.size

810:                 i = 0

811:                 while i < size

812:                         execution.grammar.remove_rule(size-i-1)

813:                         i += 1

814:                 end

815:                 

816:                 # Create default shapes for the first rule

817:                 left = ShadeUtils.create_default_left_shape()

818:                 right = ShadeUtils.create_default_right_shape()

819:                 

820:                 # Create the first rule

821:                 rule = ShadeUtils.paint_rule(1, left, right)

822:                 execution.grammar.add_rule(rule)

823:                 execution.grammar.saved = true

824:                 

825:                 #Create the axiom

826:                 execution.grammar.axiom = create_default_axiom

827:                 execution.reset

828:                 

829:                 Shade.project.refresh

830:         end
create_default_new_project() click to toggle source

Creates and loads a new project

     # File lib/utils.rb, line 835
835:         def ShadeUtils.create_default_new_project()

836:                 project = Shade.project

837:                 project.set_title(Constants::DEFAULT_PROJECT_TITLE)

838:                 

839:                 project.set_path(nil)

840:                 

841:                 ShadeUtils.create_default_new_grammar()

842:                 

843:                 project.execution.constraints = Array.new

844:                 project.execution.goals = Array.new

845:                 

846:                 project.refresh

847:                 

848:                 project.saved = true

849:         end
create_default_project() click to toggle source
returns

a default project

     # File lib/utils.rb, line 852
852:         def ShadeUtils.create_default_project

853:                 

854:                 # Create the grammar

855:                 grammar = Grammar.new

856:                 

857:                 # Create the execution

858:                 execution = Execution.new(grammar, nil)

859:                 

860:                 # Create the project

861:                 project = Project.new(execution)

862:                 

863:                 #Add the project to Shade

864:                 Shade.project = project

865:                 

866:                 #Create default shapes for the first rule

867:                 left = ShadeUtils.create_default_left_shape()

868:                 right = ShadeUtils.create_default_right_shape()

869:                 

870:                 #Create the axiom

871:                 execution.grammar.axiom = create_default_axiom

872:                 execution.current_shape = create_default_current_shape

873: 

874:                 # Create the first rule

875:                 rule = ShadeUtils.paint_rule(1, left, right)

876:                 

877: 

878:                 # Add rule to the grammar

879:                 grammar.add_rule rule

880:                 

881:                 grammar.saved = true

882:                 

883:                 # Associate the grammar with the execution

884:                 execution.grammar = grammar

885:                 

886:                 if Shade.using_sketchup

887:                         # We only need to do this once. Then, only changing observed ids is needed

888:                         Shade.rule_groups_observer = RuleGroupsObserver.new

889:                         Sketchup.active_model.entities.add_observer(Shade.rule_groups_observer)

890:                 end

891:                 

892:                 # Return the project  

893:                 return project

894:         end
create_default_right_shape() click to toggle source
returns

a default right shape for the rules

     # File lib/utils.rb, line 625
625:         def ShadeUtils.create_default_right_shape()

626:                 shape = RuleLabelledShape.new(Array.new, Array.new, nil, nil)

627:                 segments = Array.new

628:                 segments[0] = Segment.new(OrderedPoint.new(Constants::PTS_1[0].clone), OrderedPoint.new(Constants::PTS_1[1].clone))

629:                 segments[1] = Segment.new(OrderedPoint.new(Constants::PTS_1[1].clone), OrderedPoint.new(Constants::PTS_1[2].clone))

630:                 segments[2] = Segment.new(OrderedPoint.new(Constants::PTS_1[2].clone), OrderedPoint.new(Constants::PTS_1[3].clone))

631:                 segments[3] = Segment.new(OrderedPoint.new(Constants::PTS_1[3].clone), OrderedPoint.new(Constants::PTS_1[0].clone))

632:                 

633:                 segments[4] = Segment.new(OrderedPoint.new(Constants::PTS_2[0].clone), OrderedPoint.new(Constants::PTS_2[1].clone))

634:                 segments[5] = Segment.new(OrderedPoint.new(Constants::PTS_2[1].clone), OrderedPoint.new(Constants::PTS_2[2].clone))

635:                 segments[6] = Segment.new(OrderedPoint.new(Constants::PTS_2[2].clone), OrderedPoint.new(Constants::PTS_2[3].clone))

636:                 segments[7] = Segment.new(OrderedPoint.new(Constants::PTS_2[3].clone), OrderedPoint.new(Constants::PTS_2[0].clone))

637:                 

638:                 if Shade.using_sketchup

639:                         Sketchup.active_model.layers.each { |layer|

640:                                 segments.each { |segment|

641:                                         segment_list = LinearLinkedList.new

642: 

643:                                         node = LinearLinkedListNode.new(segment.line_descriptor.clone, segment_list, nil)

644:                                         

645:                                         inserted_node = shape.s[layer.name].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

646:                                         segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

647:                                         inserted_node.list.insert_node(segment_node)

648:                                 }

649: 

650:                                 Constants::PTS_1.each {|point|

651:                                         label = Label.new(Constants::INTERSECTION_LABEL)

652:                                         point_list = LinearLinkedList.new

653:                                         

654:                                         node = LinearLinkedListNode.new(label, point_list, nil)

655:                                         

656:                                         inserted_node = shape.p[layer.name].insert_node(node) #Insert the node corresponding to the label of the point

657:                                 

658:                                         point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

659:                                         inserted_node.list.insert_node(point_node) #Insert the point node

660:                                 }

661:                                 

662:                                 Constants::PTS_2.each {|point|

663:                                         label = Label.new(Constants::INTERSECTION_LABEL)

664:                                         point_list = LinearLinkedList.new

665:                                         

666:                                         node = LinearLinkedListNode.new(label, point_list, nil)

667:                                         

668:                                         inserted_node = shape.p[layer.name].insert_node(node) #Insert the node corresponding to the label of the point

669:                                 

670:                                         point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

671:                                         inserted_node.list.insert_node(point_node) #Insert the point node

672:                                 }

673:                                 

674:                                 label = Label.new(Constants::INTERSECTION_LABEL)

675:                                 intersection_label_node = shape.p[layer.name].get_node(label)

676:                         

677:                                 #Insert the other intersection points

678:                                 point_node1 = LinearLinkedListNode.new(OrderedPoint.new(Geom::Point3d.new(4,8,0)), nil, nil)

679:                                 point_node2 = LinearLinkedListNode.new(OrderedPoint.new(Geom::Point3d.new(8,4,0)), nil, nil)

680:                                 intersection_label_node.list.insert_node(point_node1) #Insert the point node

681:                                 intersection_label_node.list.insert_node(point_node2) #Insert the point node

682:                         }

683:                         

684:                         shape.changed = true

685:                 else

686:                         segments.each { |segment|

687:                                 segment_list = LinearLinkedList.new

688: 

689:                                 node = LinearLinkedListNode.new(segment.line_descriptor.clone, segment_list, nil)

690:                                 

691:                                 inserted_node = shape.s["Layer0"].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

692:                                 segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

693:                                 inserted_node.list.insert_node(segment_node)

694:                         }

695: 

696:                         Constants::PTS_1.each {|point|

697:                                 label = Label.new(Constants::INTERSECTION_LABEL)

698:                                 point_list = LinearLinkedList.new

699:                                 

700:                                 node = LinearLinkedListNode.new(label, point_list, nil)

701:                                 

702:                                 inserted_node = shape.p["Layer0"].insert_node(node) #Insert the node corresponding to the label of the point

703:                         

704:                                 point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

705:                                 inserted_node.list.insert_node(point_node) #Insert the point node

706:                         }

707:                         

708:                         Constants::PTS_2.each {|point|

709:                                 label = Label.new(Constants::INTERSECTION_LABEL)

710:                                 point_list = LinearLinkedList.new

711:                                 

712:                                 node = LinearLinkedListNode.new(label, point_list, nil)

713:                                 

714:                                 inserted_node = shape.p["Layer0"].insert_node(node) #Insert the node corresponding to the label of the point

715:                         

716:                                 point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

717:                                 inserted_node.list.insert_node(point_node) #Insert the point node

718:                         }

719:                         

720:                         label = Label.new(Constants::INTERSECTION_LABEL)

721:                         intersection_label_node = shape.p["Layer0"].get_node(label)

722:                 

723:                         #Insert the other intersection points

724:                         point_node1 = LinearLinkedListNode.new(OrderedPoint.new(Point.new(4,8,0)), nil, nil)

725:                         point_node2 = LinearLinkedListNode.new(OrderedPoint.new(Point.new(8,4,0)), nil, nil)

726:                         intersection_label_node.list.insert_node(point_node1) #Insert the point node

727:                         intersection_label_node.list.insert_node(point_node2) #Insert the point node

728:                 end

729:                 return shape

730:         end
create_rule_list() click to toggle source

returns: a String object with a list of the present rule IDs, for example, if there are four rules: “1|2|3|4”

     # File lib/utils.rb, line 734
734:         def ShadeUtils.create_rule_list()

735:                 execution = Shade.project.execution

736:                 rule_list = ""

737:                 rules_size = execution.grammar.rules.size

738:                 rules_size.times do |s|

739:                         if (s+1) == rules_size

740:                                 rule_list = "#{rule_list}#{s+1}"

741:                         else

742:                                 rule_list = "#{rule_list}#{s+1}|"

743:                         end

744:                 end

745:                 return rule_list

746:         end
current_shape() click to toggle source
returns

the current shape

      # File lib/utils.rb, line 1165
1165:         def ShadeUtils.current_shape()

1166:                 return Shade.project.execution.current_shape

1167:         end
first_rule_id() click to toggle source
returns

the id of the first rule applied

      # File lib/utils.rb, line 1246
1246:         def ShadeUtils.first_rule_id()

1247:                 if Shade.project.execution.execution_history

1248:                         return Shade.project.execution.execution_history.first[0]

1249:                 else

1250:                         return nil

1251:                 end

1252:         end
get_directory_from_path(path) click to toggle source
path

a String representing a path of a file inside the system

returns

the parent directory of the file represented by the path

      # File lib/utils.rb, line 1151
1151:         def ShadeUtils.get_directory_from_path(path)

1152:                 i = path.rindex("\\")

1153:                 return path[0..i]

1154:         end
get_directory_from_sketchup_path(path) click to toggle source
path

a String representing a path of a file inside the system, returned by the SketchUp utils for getting paths

returns

the parent directory of the file represented by the path

      # File lib/utils.rb, line 1159
1159:         def ShadeUtils.get_directory_from_sketchup_path(path)

1160:                 i = path.rindex("/")

1161:                 return path[0..i]

1162:         end
get_execution() click to toggle source
returns

the current execution

      # File lib/utils.rb, line 1222
1222:         def ShadeUtils.get_execution()

1223:                 return Shade.project.execution

1224:         end
get_extension(path) click to toggle source
path

a String representing a path of a file inside the system

returns

the extension of the file represented by the path

      # File lib/utils.rb, line 1138
1138:         def ShadeUtils.get_extension(path)

1139:                 if path.rindex(".")

1140:                         i = path.rindex(".") + 1

1141:                         j = (path.length) -1

1142:                         return path[i..j]

1143:                 else

1144:                         return nil

1145:                 end

1146:         end
get_grammar() click to toggle source
returns

the current grammar

      # File lib/utils.rb, line 1232
1232:         def ShadeUtils.get_grammar()

1233:                 return Shade.project.execution.grammar

1234:         end
get_labels(shape, type) click to toggle source
shape

a LabelledShape object

type

String that can take the values “ALL” (referring to all types of labels) or “INTERSECTION” (referring only to the intersection points)

returns

an Array with the lists of labels present in the current shape

      # File lib/utils.rb, line 1187
1187:         def ShadeUtils.get_labels(shape, type)

1188:                 

1189:                 labels = Array.new

1190:                 case type

1191:                         when ("ALL" or "All")

1192:                                 shape.p.each_key { |layer_name|

1193:                                         ShadeUtils.current_shape.p[layer_name].reset_iterator

1194:                                         while l_node = ShadeUtils.current_shape.p[layer_name].get_next

1195:                                                 labels.push l_node.list

1196:                                         end

1197:                                 }

1198:                         when ("INTERSECTION" or "Intersection")

1199:                                 

1200:                                 shape.p.each_key { |layer_name|

1201:                                 

1202:                                         l_node = ShadeUtils.current_shape.p[layer_name].get_node(Label.new(Constants::INTERSECTION_LABEL))

1203:                                         if l_node

1204:                                                 labels.push l_node.list

1205:                                         end

1206:                                 }

1207:                         else

1208:                                 shape.p.each_key { |layer_name|

1209:                                         l_node = ShadeUtils.current_shape.p[layer_name].get_node(Label.new(type.capitalize))

1210:                                         if l_node

1211:                                                 labels.push l_node.list

1212:                                         end

1213:                                 }

1214: 

1215:                         

1216:                 end

1217:                 

1218:                 return labels

1219:         end
get_project() click to toggle source
returns

the current project

      # File lib/utils.rb, line 1227
1227:         def ShadeUtils.get_project()

1228:                 return Shade.project

1229:         end
get_rule(rule_idx) click to toggle source
rule_idx

an integer number

returns

the rule with the specified index, that is, that is in the rule_idx position of the array of rules

      # File lib/utils.rb, line 1279
1279:         def ShadeUtils.get_rule(rule_idx)

1280:                 if rule_idx > Shade.project.execution.grammar.rules.size

1281:                         puts "Index out of range"

1282:                 else

1283:                         return Shade.project.execution.grammar.rules[rule_idx]

1284:                 end

1285:         end
get_title_from_path(path) click to toggle source
path

a String representing a path of a file inside the system

returns

the title of the file represented by the path

      # File lib/utils.rb, line 1120
1120:         def ShadeUtils.get_title_from_path(path)

1121:                 i = path.rindex("\\")+1

1122:                 j = path.rindex(".")-1

1123:                 return path[i..j]

1124:         end
get_title_from_sketchup_path(path) click to toggle source
path

a String representing a path of a file inside the system, returned by the SketchUp utils for getting paths

returns

the title of the file represented by the path

      # File lib/utils.rb, line 1129
1129:         def ShadeUtils.get_title_from_sketchup_path(path)

1130:                 i = path.rindex("/")+1

1131:                 j = path.rindex(".")-1

1132:                 return path[i..j]

1133:         end
is_projected?(point, segment) click to toggle source
point

a Point object

segment

a Segment object

returns

the distance, in meters, from point to segment (ortogonally projected)

     # File lib/utils.rb, line 410
410:         def ShadeUtils.is_projected?(point, segment)

411:                 result = false

412:                 projected_point = OrderedPoint.new(point.project_to_line(segment.line_descriptor, segment.tail, segment.head))

413:                 if segment.coincident? projected_point

414:                         result = true

415:                 end

416:                 return result

417:         end
last_rule_id() click to toggle source
returns

the id of the last rule applied

      # File lib/utils.rb, line 1237
1237:         def ShadeUtils.last_rule_id()

1238:                 if Shade.project.execution.execution_history

1239:                         return Shade.project.execution.execution_history.last[0]

1240:                 else

1241:                         return nil

1242:                 end

1243:         end
last_rule_transformation() click to toggle source
returns

the transformation of the last rule applied

      # File lib/utils.rb, line 1268
1268:         def ShadeUtils.last_rule_transformation()

1269:                 if Shade.project.execution.execution_history

1270:                         return Shade.project.execution.execution_history.last[1]

1271:                 else

1272:                         return nil

1273:                 end

1274:         end
load_custom_constraints() click to toggle source

Loads the constraints present in the directory “custom_constraints“

     # File lib/utils.rb, line 273
273:         def ShadeUtils.load_custom_constraints()

274:                 #We suppose that custom constraints have already been syntax-checked and executed

275:                 if Shade.using_sketchup

276:                         file_name = Sketchup.find_support_file Constants::STARTUP_FILE_NAME, Constants::LIB_DIR

277:                         directory = ShadeUtils.get_directory_from_sketchup_path(file_name)

278:                         custom_constraints_directory = "#{directory}/#{Constants::CONSTRAINT_FOLDER_NAME}"

279:                 else

280:                         custom_constraints_directory = "#{File.dirname(__FILE__)}/#{Constants::CONSTRAINT_FOLDER_NAME}"

281:                         custom_constraints_directory.gsub!("/", "\\")

282:                 end

283:                 old_dir = Dir.pwd

284:                 Dir.chdir(custom_constraints_directory)

285: 

286:                 #For each file inside the custom constraints directory

287:                 Dir.entries(".").each { |file_name|

288:                         if Shade.using_sketchup

289:                         file_path = "#{custom_constraints_directory}/#{file_name}"

290:                         name =  get_title_from_sketchup_path(file_path)

291:                         else

292:                         file_path = "#{custom_constraints_directory}\\#{file_name}"

293:                         name =  get_title_from_path(file_path)

294:                         end

295:                         extension = get_extension(file_path)

296:                         if extension == "txt"

297:                                 code = ""

298:                                 File.open(file_path, 'r') do |f|

299:                                         while line = f.gets

300:                                                 code += line

301:                                         end

302:                                 end

303:                                 

304:                                 #Make the right class

305:                                 class_name = name.gsub(" ", "_")

306:                                 Object.const_set(class_name, Class.new { 

307:                                 

308:                                         eval("attr_reader :name")

309:                                         

310:                                         eval("def initialize;  @name = \"#{name}\" end")

311:                                         

312:                                         eval("def satisfied?; result = true\n #{code} \n end")

313:                                         

314:                                         eval("def delete; end")

315:                                 

316:                                 })

317:                                 

318:                                 #Add the class and the name to the Shade.constraint_class_names

319:                                 constraint_class = eval("#{class_name}")

320:                                 Shade.add_constraint_class_name([constraint_class, name])

321:                         end

322:                 }

323:                 

324:                 Dir.chdir(old_dir)

325:         end
load_custom_goals() click to toggle source

Loads the goals present in the directory “custom_constraints“

     # File lib/utils.rb, line 329
329:         def ShadeUtils.load_custom_goals()

330:                 #We suppose that custom constraints have already been syntax-checked and executed

331:                 if Shade.using_sketchup

332:                         file_name = Sketchup.find_support_file Constants::STARTUP_FILE_NAME, Constants::LIB_DIR

333:                         directory = ShadeUtils.get_directory_from_sketchup_path(file_name)

334:                         custom_goals_directory = "#{directory}/#{Constants::GOAL_FOLDER_NAME}"

335:                 else

336:                         custom_goals_directory = "#{File.dirname(__FILE__)}/#{Constants::GOAL_FOLDER_NAME}"

337:                         custom_goals_directory.gsub!("/", "\\")

338:                 end

339:                 

340:                 old_dir = Dir.pwd

341:                 Dir.chdir(custom_goals_directory)

342:                 

343:                 #For each file inside the custom constraints directory

344:                 Dir.entries(".").each { |file_name|

345:                         if Shade.using_sketchup

346:                                 file_path = "#{custom_goals_directory}/#{file_name}"

347:                                 name =  get_title_from_sketchup_path(file_path)

348:                         else

349:                                 file_path = "#{custom_goals_directory}\\#{file_name}"

350:                                 name =  get_title_from_path(file_path)

351:                         end

352:                         extension = get_extension(file_path)

353:                         if extension == "txt"

354:                                 code = ""

355:                                 File.open(file_path, 'r') do |f|

356:                                         while line = f.gets

357:                                                 code += line

358:                                         end

359:                                 end

360:                                 

361:                                 #Make the right class

362:                                 class_name = name.gsub(" ", "_")

363:                                 Object.const_set(class_name, Class.new { 

364:                                 

365:                                         eval("attr_reader :name")

366:                                         

367:                                         eval("def initialize;  @name = \"#{name}\" end")

368:                                         

369:                                         eval("def satisfied?; result = true\n #{code} \n end")

370:                                         

371:                                         eval("def delete; end")

372:                                 

373:                                 })

374:                                 

375:                                 #Add the class and the name to the Shade.constraint_class_names

376:                                 goal_class = eval("#{class_name}")

377:                                 Shade.add_goal_class_name([goal_class, name])

378:                         end

379:                 }

380:                 

381:                 Dir.chdir(old_dir)

382:         end
paint_rule(id, left, right) click to toggle source

Adds observers, descends the shapes and paint lines and arrow

      # File lib/utils.rb, line 981
 981:         def ShadeUtils.paint_rule(id, left, right)

 982:                 

 983:                 execution = Shade.project.execution

 984:                 

 985:                 previous_rule = execution.grammar.search_rule_by_id(id)

 986:                 

 987:                 if previous_rule

 988:                         UI.messagebox("The id #{id} is already in use")

 989:                         return nil

 990:                 end

 991:                 

 992:                 if Shade.using_sketchup

 993:                 

 994:                         # Get handles

 995:                         entities = Sketchup.active_model.entities 

 996:                         

 997:                         if execution.grammar

 998:                                 idx = execution.grammar.rules.size 

 999:                         else

1000:                                 idx = 0

1001:                         end

1002:                         t = idx

1003: 

1004:                         # Transform the layout transformation of the shapes

1005:                         t_left = Geom::Transformation.new

1006:                         t_right = Geom::Transformation.new

1007:                         t.times do

1008:                                 t_left = Constants::DESCEND_T * t_left

1009:                                 t_right = Constants::DESCEND_T * t_right

1010:                         end

1011:                         t_left = Constants::LEFT_T * t_left

1012:                         t_right = Constants::RIGHT_T * t_right

1013:                         left.layout_transformation =  t_left

1014:                         right.layout_transformation = t_right

1015:                         

1016:                         group_arrow = Hash.new(nil)

1017:                         Sketchup.active_model.layers.each { |layer|

1018:                                 # Draw an arrow, for the rule

1019:                                 point1 = Constants::PTS_ARROW[0].clone

1020:                                 point2 = Constants::PTS_ARROW[1].clone

1021:                                 point3 = Constants::PTS_ARROW[2].clone

1022:                                 point4 = Constants::PTS_ARROW[3].clone

1023:                                 

1024:                                 t.times do

1025:                                         point1.transform! Constants::DESCEND_T 

1026:                                         point2.transform! Constants::DESCEND_T 

1027:                                         point3.transform! Constants::DESCEND_T 

1028:                                         point4.transform! Constants::DESCEND_T 

1029:                                 end

1030: 

1031:                                 group_arrow[layer.name] = entities.add_group

1032:                                 group_arrow[layer.name].entities.add_line point1, point2

1033:                                 group_arrow[layer.name].entities.add_line point3, point2

1034:                                 group_arrow[layer.name].entities.add_line point4, point2

1035:                                 group_arrow[layer.name].layer = layer

1036:                                 group_arrow[layer.name].locked = true

1037:                         }

1038:                         

1039:                         group_origin_right = Hash.new(nil)

1040:                         group_origin_left = Hash.new(nil)

1041:                         Sketchup.active_model.layers.each { |layer|

1042:                                 #Draw the origin references

1043:                                 point1 = Constants::PTS_ORIGIN[0].clone

1044:                                 point2 = Constants::PTS_ORIGIN[1].clone

1045:                                 point3 = Constants::PTS_ORIGIN[2].clone

1046:                                 point4 = Constants::PTS_ORIGIN[3].clone

1047:                                 

1048:                                 group_origin_left[layer.name] = entities.add_group

1049:                                 group_origin_left[layer.name].entities.add_edges point1, point3

1050:                                 group_origin_left[layer.name].entities.add_edges point2, point4

1051:                                 group_origin_left[layer.name].transformation = t_left

1052:                                 group_origin_left[layer.name].layer = layer

1053:                                 group_origin_left[layer.name].locked = true

1054:                                 

1055:                                 

1056:                                 group_origin_right[layer.name] = entities.add_group

1057:                                 group_origin_right[layer.name].entities.add_edges point1, point3

1058:                                 group_origin_right[layer.name].entities.add_edges point2, point4

1059:                                 group_origin_right[layer.name].transformation = t_right

1060:                                 group_origin_right[layer.name].layer = layer

1061:                                 group_origin_right[layer.name].locked = true

1062:                                 

1063:                         }

1064:                         

1065:                         line_group = Hash.new(nil)

1066:                         Sketchup.active_model.layers.each { |layer|

1067:                                 #Draw horizontal line

1068:                                 point_h1 = Constants::PTS_H[0].clone

1069:                                 point_h2 = Constants::PTS_H[1].clone

1070:                                 

1071:                                 t.times do

1072:                                         point_h1.transform! Constants::DESCEND_T 

1073:                                         point_h2.transform! Constants::DESCEND_T 

1074:                                 end

1075:                                 line_group[layer.name] = entities.add_group

1076:                                 line_group[layer.name].entities.add_line point_h1,point_h2

1077:                                 line_group[layer.name].layer = layer

1078:                                 line_group[layer.name].locked = true

1079:                                 

1080:                         }

1081:                 end

1082:                 

1083:                 # Create the rule

1084:                 rule = Rule.new(id, left, right, line_group, group_arrow, group_origin_left, group_origin_right)

1085:                 

1086:                 return rule

1087:         end
paint_rule_layout(rule_idx, layer_name) click to toggle source
rule_idx

the index of a rule

layer_name

a name of a layer

Paints the given layer of the rule specified by rule_idx

     # File lib/utils.rb, line 901
901:         def ShadeUtils.paint_rule_layout(rule_idx, layer_name)

902:                 

903:                 if Shade.using_sketchup

904:                         execution = Shade.project.execution

905:                         rule = execution.grammar.rules[rule_idx]

906: 

907:                         entities = Sketchup.active_model.entities 

908:                         

909:                         t = rule_idx

910:                                 

911:                         Sketchup.active_model.layers.each { |layer|

912:                                 if layer.name == layer_name

913:                                         # Draw an arrow, for the rule

914:                                         point1 = Constants::PTS_ARROW[0].clone

915:                                         point2 = Constants::PTS_ARROW[1].clone

916:                                         point3 = Constants::PTS_ARROW[2].clone

917:                                         point4 = Constants::PTS_ARROW[3].clone

918:                                         

919:                                         t.times do

920:                                                 point1.transform! Constants::DESCEND_T 

921:                                                 point2.transform! Constants::DESCEND_T 

922:                                                 point3.transform! Constants::DESCEND_T 

923:                                                 point4.transform! Constants::DESCEND_T 

924:                                         end

925: 

926:                                         rule.arrow_group[layer.name] = entities.add_group

927:                                         rule.arrow_group[layer.name].entities.add_line point1, point2

928:                                         rule.arrow_group[layer.name].entities.add_line point3, point2

929:                                         rule.arrow_group[layer.name].entities.add_line point4, point2

930:                                         rule.arrow_group[layer.name].layer = layer

931:                                         rule.arrow_group[layer.name].locked = true

932:                                 end

933:                         }

934: 

935:                         Sketchup.active_model.layers.each { |layer|

936:                                 if layer.name == layer_name

937:                                         #Draw the origin references

938:                                         point1 = Constants::PTS_ORIGIN[0].clone

939:                                         point2 = Constants::PTS_ORIGIN[1].clone

940:                                         point3 = Constants::PTS_ORIGIN[2].clone

941:                                         point4 = Constants::PTS_ORIGIN[3].clone

942:                                         

943:                                         rule.group_origin_left[layer.name] = entities.add_group

944:                                         rule.group_origin_left[layer.name].entities.add_edges point1, point3

945:                                         rule.group_origin_left[layer.name].entities.add_edges point2, point4

946:                                         rule.group_origin_left[layer.name].transformation = rule.left.layout_transformation

947:                                         rule.group_origin_left[layer.name].layer = layer

948:                                         rule.group_origin_left[layer.name].locked = true

949:                                         

950:                                         

951:                                         rule.group_origin_right[layer.name] = entities.add_group

952:                                         rule.group_origin_right[layer.name].entities.add_edges point1, point3

953:                                         rule.group_origin_right[layer.name].entities.add_edges point2, point4

954:                                         rule.group_origin_right[layer.name].transformation = rule.right.layout_transformation

955:                                         rule.group_origin_right[layer.name].layer = layer

956:                                         rule.group_origin_right[layer.name].locked = true

957:                                 end

958:                         }

959:                         

960:                         Sketchup.active_model.layers.each { |layer|

961:                                 if layer.name == layer_name

962:                                         #Draw horizontal line

963:                                         point_h1 = Constants::PTS_H[0].clone

964:                                         point_h2 = Constants::PTS_H[1].clone

965:                                         

966:                                         t.times do

967:                                                 point_h1.transform! Constants::DESCEND_T 

968:                                                 point_h2.transform! Constants::DESCEND_T 

969:                                         end

970:                                         rule.line_group[layer.name] = entities.add_group

971:                                         rule.line_group[layer.name].entities.add_line point_h1,point_h2

972:                                         rule.line_group[layer.name].layer = layer

973:                                         rule.line_group[layer.name].locked = true

974:                                 end

975:                         }

976:                 end

977:         end
point_segment_distance(point, segment) click to toggle source
point

a Point object

segment

a Segment object

returns

the distance, in meters, from point to segment (ortogonally projected)

     # File lib/utils.rb, line 391
391:         def ShadeUtils.point_segment_distance(point, segment)

392:                 projected_point = OrderedPoint.new(point.project_to_line(segment.line_descriptor, segment.tail, segment.head))

393:                 if segment.coincident? projected_point

394:                         distance = point.distance(projected_point.point)

395:                 else

396:                         distance_start = point.distance(segment.tail.point)

397:                         distance_end = point.distance(segment.head.point)

398:                         distance = distance_end

399:                         if distance_start < distance_end

400:                                 distance = distance_start

401:                         end

402:                 end

403:                 return distance

404:         end
prepare_canvas(axes = true) click to toggle source
axes

true iff the axes are to be shown

Prepares the canvas for the plugin

      # File lib/utils.rb, line 1094
1094:         def ShadeUtils.prepare_canvas(axes = true)

1095:                 if Shade.using_sketchup

1096:                         # Prepare view

1097:                         Sketchup.send_action("viewTop:")

1098:                         if axes

1099:                                 Sketchup.send_action("viewShowAxes:")

1100:                         end

1101:                         

1102:                         # Center view 

1103:                         eye = [Constants::PTS_H[1][0], Constants::PTS_H[1][1], Constants::INITIAL_Z_CAMERA]

1104:                         target = Constants::PTS_H[1]

1105:                         up = Sketchup.active_model.active_view.camera.up

1106:                         Sketchup.active_model.active_view.camera.set eye, target, up

1107:                         

1108:                         # Draw vertical line

1109:                         point1 = Constants::PTS_V[0].clone

1110:                         point2 = Constants::PTS_V[1].clone

1111:                         group = Sketchup.active_model.entities.add_group

1112:                         group.entities.add_line point1,point2

1113:                 end

1114:         end
previous_rule_id() click to toggle source
returns

the id of the rule applied previously to the last one

      # File lib/utils.rb, line 1255
1255:         def ShadeUtils.previous_rule_id()

1256:                 if Shade.project.execution.execution_history

1257:                         if Shade.project.execution.execution_history.size > 1

1258:                                 return Shade.project.execution.execution_history[Shade.project.execution.execution_history.size - 2][0]

1259:                         else

1260:                                 return nil

1261:                         end

1262:                 else

1263:                         return nil

1264:                 end

1265:         end
previous_shape() click to toggle source
returns

the shape previous to the last rule application

      # File lib/utils.rb, line 1170
1170:         def ShadeUtils.previous_shape()

1171:                 if Shade.project.execution.execution_history

1172:                         return Shade.project.execution.execution_history.last[2]

1173:                 else

1174:                         return nil

1175:                 end

1176:         end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.