Projet Construction Ossature Bois

william bilcot a écrit:salut tous le monde.

pour moi il y a plus de mille façon de faire et de voir les choses dans les structures ossature bois.
ça fait déjà un petit moment que je travail dans la charpente et je vous dirais que l'on voit des maisons bois construitent avec tant de méthodes que l'on ne s'est plus quelles sont les règles à suivre.

on pourrait faire un grand débat mais ça n'en finira pas, car les structures ne seront jamais les même.

ce petit livre et très intéressent et je ne le trouve pas si chère que ça. il est de bonne inspiration.

j'ai envoyé a plassais l'ensemble du livre pour qu'il ait le max d'infos.

pour les joins de dalle je pense qui ne faut pas ce prendre la tête, comme je disais à plassais je trouve mieux d'avoir un seul groupe pour l'ensemble de l'osb 16 ou18 ou autres.
c'est moins lourd dans le fichier, car quand on rentre dans le détail d'une maison bois il n'y a pas que la dalle bois qui a son importance. de plus lorsque l'on veut métrer les surfaces de dalle osb pour faire une commande ou un devis c' est difficile, en plus on compte toujours un pourcentage de perte dans les matériaux que l'on met en œuvre.

pour les cloisons on retient en épaisseur. 50mm,70mm,90mm,120mm.
quand on passe en 145mm,220mm on est plus dans des cloisons porteuses, et la il vaut mieux être sur une poutre ou trouver d'autre solution, car même le plugin fini il faut pas croire qu'il n'y aura plus de travail a faire. et c'est ça qui et bon dans notre métier ,c'est que la machine ne pourra pas nous replacer.
il faudra toujours trouver une solution technique que l'on trouvera pas dans les livres.

pour les entretoises il serait mieux de rester dans les 45mm de retombée (hauteur), pour éviter les déperdition thermique. il vaut mieux en mettre plus serré a vous de juger, cas par cas.




.

Sebdhem a écrit:@C.plassais : Christophe? t'en est où pour le codage final de cette partie?

J'ai lancé aussi le début du cahier des charges pour les murs et cloisons : tu pourras regarder quand tu en auras le temps et décrire simplement le déroulement du script. pour que l'on puisse voir comment aborder cela.

c.plassais a écrit:

Sebdhem a écrit:@C.plassais : Christophe? t'en est où pour le codage final de cette partie?

J'ai lancé aussi le début du cahier des charges pour les murs et cloisons : tu pourras regarder quand tu en auras le temps et décrire simplement le déroulement du script. pour que l'on puisse voir comment aborder cela.

Bonsoir :icon_mrgreen:

J'y passe une dizaine d'heures par jour et pratiquement tous les jours de la semaine
mais je manquerai pas de prevenir les autorités, quand j'aurai solutionné le problème.

Bonne continuation

Sebdhem a écrit:Encore un problème? Quel problème?

De mon côté j'essaie de compléter le cahier des charges pour le module des murs.

Code:

# Designed December 2010 by ChrisP

# Permission to use this software for any purpose and without fee is hereby granted
# Distribution of this software for commercial purpose is forbidden:

# THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
# IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
#-----------------------------------------------------------------------------
# Name        :    WoodStock
# Original Date  :  30 Janv 2010 version 0.0 (thx to Jojo2 and Sebdhem)
# Type        :  Plugin
# Description  :  Wood Constructions
# Usage        :  Click - Plugin Menu
# Version 0.1.0
#-------------------------------------------------------------------------------------------------------------------------------------------

require 'sketchup.rb'

# Classe gestion des arrondis **************************************************************************************************************
class Float
  def round_to(x)
    (self*10**x).round.to_f/10**x
  end
  def ceil_to(x)
    (self*10**x).ceil.to_f/10**x
  end
  def floor_to(x)
    (self*10**x).floor.to_f/10**x
  end
end

# debut du module **************************************************************************************************************************

module WoodStock

# parametres et données utilisateur ########################################################################################################

    def self.init_general
        @model = Sketchup.active_model
        @entities = @model.active_entities
        @definitions = @model.definitions
        @selection = @model.selection
        @layers = @model.layers
        @separateur = Sketchup.parse_length("9.9")

    end

    def self.unite_conv(unite_comp)
        unite_comp = separateur_conv(unite_comp)
        unite_comp = Sketchup.parse_length unite_comp
        unite_modele = @model.options["UnitsOptions"]["LengthUnit"]
          case unite_modele
            when unite_modele = 0
                unite_comp = unite_comp / 2.54
            when unite_modele = 1
              unite_comp = unite_comp * 0.032808399
            when unite_modele = 2
                unite_comp = unite_comp * 10
            when unite_modele = 3
                unite_comp = unite_comp
            when unite_modele = 4
                unite_comp = unite_comp / 100
          end
    end

    def self.separateur_conv(separateur)
        if not @separateur
            separateur.gsub(/[.]/,',\1')
        else
            separateur.gsub(/[,]/,'.\1')
        end
    end


    def self.param_plancher_rdc
          # données utilisateur
          @point_depart = []
          @point_depart[0] = 0
          @point_depart[1] = 0
          @point_depart[2] = 0
          @unite_angle = 1.degrees
          angle = 90
          @angle = angle * @unite_angle
          @hauteur_report = 0
          @hauteur_report = 0
          @portee_mini = "2"
          @portee_mini = unite_conv(@portee_mini)
          @ecart_mini_joint = "30"
          @ecart_mini_joint = unite_conv(@ecart_mini_joint)

    end

    def self.param_etrier
    rotation_etrier = 180
    @rotation_etrier = rotation_etrier.degrees
    @axe_rotation = [0, 0,1]
    end
############################################################################################################################################
# conception module Plancher RDC ###########################################################################################################
############################################################################################################################################

# Appels des modules en fonction des options cochées  ######################################################################################

    def self.plancher_rdc
        init_general
        param_plancher_rdc
        if(@ceinture == "true")
        ceinture
        @ceinture = "false"
        end
        if(@poutre == "true")
        poutre
        @poutre = "false"
        end
        if(@etrier == "true")
        etrier
        @etrier = "false"
        end
        if(@sousplancher == "true")
        sous_plancher
        @sousplancher = "false"
        end
        if(@isolant == "true")
        isolant
        @isolant = "false"
        end
        if(@parevapeur == "true")
        pare_vapeur
        @parevapeur = "false"
        end
        if(@surplancher == "true")
        sur_plancher
        @surplancher = "false"
        end
        (@group_global) ? (group_global = @entities.add_group(@selection)) : (@selection.clear)
    end

# Pose Ceinture ############################################################################################################################

    def self.ceinture
          @repertoire = "Ceinture"
          menu_module
          (@double_ceint) ? (@double_ceint = 2) : (@double_ceint = 1)
          @largeur_ceint = @componentdefinition.get_attribute "Parametres_base", "largeur", 0
          @largeur_ceint = unite_conv (@largeur_ceint)
          @haut_ceint = @componentdefinition.get_attribute "Parametres_base", "hauteur", 0
          @haut_ceint = unite_conv (@haut_ceint)
          @larg_int = @larg - (@largeur_ceint * 2)
          @long_int = @long - (@largeur_ceint * (@double_ceint * 2))
          @epais_ceint = @largeur_ceint * @double_ceint
          point_debut = []
          point_fin = []
          point_debut[0] =  [@long, 0, - @haut_ceint]
          point_fin[0] = [@point_depart[0],@point_depart[1], @point_depart[2] - @haut_ceint]
          point_debut[1] = [@long - @largeur_ceint , @largeur_ceint, - @haut_ceint]
          point_fin[1] = [@long - @largeur_ceint, @larg - @largeur_ceint, - @haut_ceint]
          point_debut[2] = [@long, @larg - @largeur_ceint, - @haut_ceint]
          point_fin[2] = [0, @larg - @largeur_ceint,- @haut_ceint]
          point_debut[3] = [0, @largeur_ceint, - @haut_ceint]
          point_fin[3] = [0, @larg - @largeur_ceint, - @haut_ceint]
            unless(@double_ceint == 1)
              point_debut[4] = [@long - @epais_ceint , @largeur_ceint, - @haut_ceint]
              point_fin[4] = [@long - @epais_ceint, @larg - @largeur_ceint, - @haut_ceint]
              point_debut[5] = [@largeur_ceint, @largeur_ceint, - @haut_ceint]
              point_fin[5] = [@largeur_ceint, @larg - @largeur_ceint, - @haut_ceint]
            end
                  @model.start_operation @repertoire
                  calque = @layers.add @repertoire if(@sur_calque)
                  group_comp = @entities.add_group if(@groupage)
                  (@groupage) ? (entities = group_comp.entities) : (entities = @entities)
                  point_debut.length.times  { |x|
                  trans = Geom::Transformation.new point_debut[x]
                  distance = point_debut[x].distance point_fin[x]
                  instance = entities.add_instance @componentdefinition, trans
                  instance.layer = calque
                  (@groupage) ? (@ss = @selection.add group_comp) : (@ss = @selection.add instance)
                  long_comp = instance.bounds.height
                  coefficient = distance / long_comp
                  etir_comp = Geom::Transformation.scaling point_debut[x], 1.0, coefficient, 1.0
                  instance.transform!(etir_comp)
                  vect = point_debut[x].vector_to point_fin[x]
                  vecteur = vect.normalize
                      if(vecteur.x != 0)
                          t = Geom::Transformation.rotation point_debut[x], [0,0,1], @angle
                          instance.transform!(t)
                      end
                }
                @model.commit_operation
                @double_ceint = false
    end

# Pose Poutre ##############################################################################################################################

    def self.poutre
          @repertoire = "Poutre"
          menu_module
          @largeur_poutre = @componentdefinition.get_attribute "Parametres_base", "largeur", 0
          @largeur_poutre = unite_conv (@largeur_poutre)
          @haut_poutre = @componentdefinition.get_attribute "Parametres_base", "hauteur", 0
          @haut_poutre = unite_conv (@haut_poutre)
          @epais_lint_pout = @componentdefinition.get_attribute "Parametres_base", "epais_base", 0
          @epais_lint_pout = unite_conv (@epais_lint_pout)
          @largeur_ame = @componentdefinition.get_attribute "Parametres_base", "epais_ame", 0
          @largeur_ame = unite_conv (@largeur_ame)
          @largeur_ceint = 1 if not(@largeur_ceint)
          @long_int = @long if not (@long_int)
          @larg_int = @larg if not (@larg_int)
          entraxe = (@long - (@epais_ceint * 2) + @largeur_poutre) / @entraxe
          nb_entraxe =  entraxe.ceil_to(0)
          @entraxe = (@long - (@epais_ceint * 2) + @largeur_poutre) / nb_entraxe
          @entraxe_ame = @entraxe - @largeur_ame
          boucle = @entraxe + @epais_ceint - @largeur_poutre
                @model.start_operation @repertoire
                  calque = @layers.add @repertoire if(@sur_calque)
                  group_comp = @entities.add_group if(@groupage)
                  (@groupage) ? (entities = group_comp.entities) : (entities = @entities)
                      while(boucle < @long_int)
                          point_dep_poutre = [boucle, @largeur_ceint, - @haut_poutre]
                          trans = Geom::Transformation.new point_dep_poutre
                          instance = entities.add_instance @componentdefinition, trans
                          instance.layer = calque
                          (@groupage) ? (@ss = @selection.add group_comp) : (@ss = @selection.add instance)
                          long_comp = instance.bounds.height
                          coefficient = @larg_int / long_comp
                          etir_comp = Geom::Transformation.scaling point_dep_poutre, 1.0, coefficient, 1.0
                          instance.transform!(etir_comp)
                      boucle = boucle + @entraxe
                    end
                    boucle = 0
                @model.commit_operation
    end

# Pose Etrier ##############################################################################################################################

    def self.etrier
          @repertoire = "Etrier"
          menu_module
          @epais_etrier = @componentdefinition.get_attribute "Parametres_base", "epaisseur", 0
          @epais_etrier = unite_conv (@epais_etrier)
          param_etrier
          boucle = @entraxe + @epais_ceint - @largeur_poutre
              @model.start_operation @repertoire
              calque = @layers.add @repertoire if(@sur_calque)
              group_comp = @entities.add_group if(@groupage)
              (@groupage) ? (entities = group_comp.entities) : (entities = @entities)
                  while(boucle < @long_int )
                        point_dep_poutre = [boucle, @largeur_ceint, - @haut_poutre]
                        point_fin_poutre = [ boucle, @larg_int - @epais_etrier, - @haut_poutre]
                        trans_debut = Geom::Transformation.new point_dep_poutre
                        instance = entities.add_instance @componentdefinition, trans_debut
                        instance.layer = calque
                        (@groupage) ? (@ss = @selection.add group_comp) : (@ss = @selection.add instance)
                        trans_fin = Geom::Transformation.new point_fin_poutre
                        instance = entities.add_instance @componentdefinition, trans_fin
                        instance.layer = calque
                        (@groupage) ? (@ss = @selection.add group_comp) : (@ss = @selection.add instance)
                        centre_etrier = instance.bounds.center
                        rotation = Geom::Transformation.rotation centre_etrier, @axe_rotation, @rotation_etrier
                        instance.transform!(rotation)
                    boucle = boucle + @entraxe
                  end
                  boucle = 0
              @model.commit_operation
    end

# Pose Sous-plancher #######################################################################################################################

    def self.sous_plancher

          @repertoire = "Linteau"
          menu_module
          @larg_linteau = @componentdefinition.get_attribute "Parametres_base", "largeur", 0
          @larg_linteau = unite_conv (@larg_linteau)
          @hauteur_linteau = @componentdefinition.get_attribute "Parametres_base", "hauteur", 0
          @hauteur_linteau = unite_conv (@hauteur_linteau)
              @model.start_operation "linteau"
              calque = @layers.add @repertoire if(@sur_calque)
              group_comp = @entities.add_group if(@groupage)
              (@groupage) ? (entities = group_comp.entities) : (entities = @entities)
                      boucle = @epais_ceint
                      2.times {
                      point_dep_linteau = [boucle, @largeur_ceint, - ((@haut_poutre - @epais_lint_pout) + @hauteur_linteau )  ]
                      trans = Geom::Transformation.new point_dep_linteau
                      instance = entities.add_instance @componentdefinition, trans
                      instance.layer = calque
                      (@groupage) ? (@ss = @selection.add group_comp) : (@ss = @selection.add instance)
                      long_comp = instance.bounds.height
                      coefficient = @larg_int / long_comp
                      etir_comp = Geom::Transformation.scaling point_dep_linteau, 1.0, coefficient, 1.0
                      instance.transform!(etir_comp)
                      boucle = @long - boucle - @larg_linteau
                      }
              @model.commit_operation

          @repertoire = "OSB_Sous_Plancher"
          menu_module
          @larg_planche_sous = @componentdefinition.get_attribute "Parametres_base", "largeur", 0
          @larg_planche_sous = unite_conv (@larg_planche_sous)
          @long_planche_sous = @componentdefinition.get_attribute "Parametres_base", "longueur", 0
          @long_planche_sous = unite_conv (@long_planche_sous)
          @epais_planche_sous = @componentdefinition.get_attribute "Parametres_base", "epaisseur", 0
          @epais_planche_sous = unite_conv (@epais_planche_sous)
          boucle1 = @epais_ceint - ((@largeur_poutre - @largeur_ame)/2)
          boucle  = 0
          chute_long = @long_planche_sous
          deport_dep = 0
          dep_sous_plan = 0
              @model.start_operation @repertoire
              (@sur_calque) ? (calque = @layers.add @repertoire) : (@sur_calque)
              group_comp = @entities.add_group if(@groupage)
              (@groupage) ? (entities = group_comp.entities) : (entities = @entities)
                    while(boucle1 < @long_int)
                        while(boucle < @larg_int)
                            (dep_sous_plan ==0) ? (point_dep_sousplan = [boucle1 + ((@largeur_poutre - @largeur_ame)/2) , @largeur_ceint + boucle, - (@haut_poutre - @epais_lint_pout)]) : (point_dep_sousplan = [boucle1, @largeur_ceint + boucle, - (@haut_poutre - @epais_lint_pout)])
                            trans = Geom::Transformation.new point_dep_sousplan
                            instance = entities.add_instance @componentdefinition, trans
                            instance.layer = calque
                            (@groupage) ? (@ss = @selection.add group_comp) : (@ss = @selection.add instance)
                                     if((boucle + @long_planche_sous > @larg_int) and (chute_long >= @mini_chute_long ))
                                            depassement = (boucle + chute_long) - @larg_int
                                            part_conserv = chute_long - depassement
                                            coefficient1 = part_conserv / @long_planche_sous
                                            chute_long = depassement
                                            deport_dep = 0
                                      elsif((boucle == 0) and (chute_long >= @mini_chute_long))
                                            coefficient1 = chute_long / @long_planche_sous
                                            deport_dep = @long_planche_sous - chute_long
                                            chute_long = @long_planche_sous
                                      else
                                            coefficient1 = 1.0
                                            chute_long = @long_planche_sous
                                            deport_dep = 0
                                      end

                            if( boucle1 + @entraxe_ame) < @long_int
                                if(dep_sous_plan ==0)
                                    coefficient = (@entraxe_ame - ((@largeur_poutre - @largeur_ame)/2))/ @larg_planche_sous
                                else
                                    coefficient = @entraxe_ame / @larg_planche_sous
                                end
                            else
                                reste_larg = @long - boucle1 - @epais_ceint
                                coefficient = reste_larg / @larg_planche_sous
                            end

                            etir_comp = Geom::Transformation.scaling point_dep_sousplan, coefficient, coefficient1, 1.0
                            instance.transform!(etir_comp)
                          boucle += (@long_planche_sous - deport_dep)
                        end
                        dep_sous_plan = 1
                        boucle = 0
                        boucle1 += @entraxe_ame + @largeur_ame
                    end
                    boucle1 = 0
              @model.commit_operation
    end
# Pose Isolant  ############################################################################################################################

    def self.isolant
          @repertoire = "Isolant"
          menu_module
          @larg_isolant = @componentdefinition.get_attribute "Parametres_base", "largeur", 0
          @larg_isolant = unite_conv (@larg_isolant)
          boucle = @epais_ceint - ((@largeur_poutre - @largeur_ame)/2)
          dep_isolant = 0
                @model.start_operation @repertoire
                calque = @layers.add @repertoire if(@sur_calque)
                group_comp = @entities.add_group if(@groupage)
                (@groupage) ? (entities = group_comp.entities) : (entities = @entities)
                      while(boucle < @long_int)
                              (dep_isolant == 0) ? (point_dep_isolant = [boucle + ((@largeur_poutre - @largeur_ame)/2), @largeur_ceint, - (@haut_poutre - @epais_planche_sous - @epais_lint_pout)]) : (point_dep_isolant = [boucle, @largeur_ceint, - (@haut_poutre - @epais_planche_sous - @epais_lint_pout)])
                              trans = Geom::Transformation.new point_dep_isolant
                              instance = entities.add_instance @componentdefinition, trans
                              instance.layer = calque
                              (@groupage) ? (@ss = @selection.add group_comp) : (@ss = @selection.add instance)
                              long_comp = instance.bounds.height
                              coefficient1 = @larg_int / long_comp

                              if( boucle + @entraxe_ame) < @long_int
                                  if(dep_isolant == 0)
                                        coefficient = (@entraxe_ame - ((@largeur_poutre - @largeur_ame)/2)) / @larg_isolant
                                        dep_isolant = 1
                                  else
                                        coefficient = @entraxe_ame / @larg_isolant
                                  end
                              else
                                  reste_larg = @long - boucle - @epais_ceint
                                  coefficient = reste_larg / @larg_isolant
                              end

                              etir_comp = Geom::Transformation.scaling point_dep_isolant, coefficient, coefficient1, 1.0
                              instance.transform!(etir_comp)
                              boucle += @entraxe_ame + @largeur_ame
                          end
                              boucle = 0
                @model.commit_operation
    end
# Pose Pare-vapeur #########################################################################################################################

    def self.pare_vapeur
        @repertoire = "Pare_Vapeur"
        menu_module
        @larg_parevap = @componentdefinition.get_attribute "Parametres_base", "largeur", 0
        @larg_parevap = unite_conv (@larg_parevap)
        @epais_parevap = @componentdefinition.get_attribute "Parametres_base", "epaisseur", 0
        @epais_parevap = unite_conv (@epais_parevap)
        @hauteur_report = @hauteur_report + @epais_parevap
        nombre_lai = @long / @larg_parevap
        @nombre_lai = nombre_lai.to_i
        boucle = 0
              @model.start_operation @repertoire
              calque = @layers.add @repertoire if(@sur_calque)
              group_comp = @entities.add_group if(@groupage)
              (@groupage) ? (entities = group_comp.entities) : (entities = @entities)
                    while(boucle <(@nombre_lai * @larg_parevap))
                        point_dep_parevap = [@point_depart[0] + boucle + @offset_plancher, @point_depart[1] + @offset_plancher, @point_depart[2]]
                        trans = Geom::Transformation.new point_dep_parevap
                        instance = entities.add_instance @componentdefinition, trans
                        instance.layer = calque
                        (@groupage) ? (@ss = @selection.add group_comp) : (@ss = @selection.add instance)
                        long_comp = instance.bounds.height
                        coefficient = (@larg -(@offset_plancher * 2)) / long_comp
                        etir_comp = Geom::Transformation.scaling point_dep_parevap, 1.0, coefficient, 1.0
                        instance.transform!(etir_comp)
                    boucle += @larg_parevap

                  end

                  reste = @long - (@nombre_lai * @larg_parevap)
                  point_dep_parevap = [@point_depart[0] + boucle + @offset_plancher, @point_depart[1] + @offset_plancher, @point_depart[2]]
                  trans = Geom::Transformation.new point_dep_parevap
                  instance = entities.add_instance @componentdefinition, trans
                  instance.layer = calque
                  (@groupage) ? (@ss = @selection.add group_comp) : (@ss = @selection.add instance)
                  long_comp = instance.bounds.height
                  coefficient = (@larg - (@offset_plancher * 2)) / long_comp
                  larg_comp = (reste - (@offset_plancher * 2)) / @larg_parevap
                  etir_comp = Geom::Transformation.scaling point_dep_parevap, larg_comp, coefficient, 1.0
                  instance.transform!(etir_comp)
                  boucle = 0
              @model.commit_operation

    end
# Pose Sur-plancher ########################################################################################################################

    def self.sur_plancher
          @repertoire = "OSB_Sur_Plancher"
          menu_module
          @long_planche_sur = @componentdefinition.get_attribute "Parametres_base", "longueur", 0
          @long_planche_sur = unite_conv (@long_planche_sur)
          @larg_planche_sur = @componentdefinition.get_attribute "Parametres_base", "largeur", 0
          @larg_planche_sur = unite_conv (@larg_planche_sur)
          @epais__planche_sur = @componentdefinition.get_attribute "Parametres_base", "epaisseur", 0
          @epais__planche_sur = Sketchup.parse_length @epais__planche_sur
          @mini_chute_sauv = @mini_chute_long
          @mini_chute_long = (((@entraxe - (@largeur_poutre / 2) + @epais_ceint) - ((@largeur_poutre / 2) - @portee_mini))+ ((@appui_mini - 2) * @entraxe)) if(@appui_mini > 1 )
          boucle_long = 0
          boucle_report = @epais_ceint + @entraxe_ame + @largeur_ame - (@largeur_poutre / 2)
          boucle_report_sauv = boucle_report
          boucle_larg  = 0
          chute_long = @long_planche_sur
          deport_dep = 0
          long_sauv = 0
          part_long_coupe = 0
          part_larg_coupe = 0
          long_fin = 0
          larg_fin = 0
          coef_long = 0
          coef_larg = 0
                @model.start_operation @repertoire
                calque = @layers.add @repertoire if(@sur_calque)
                group_comp = @entities.add_group if(@groupage)
                (@groupage) ? (entities = group_comp.entities) : (entities = @entities)
                        if (@joint_sur_axe =="true")# Pas de gestion des entraxes#####################################################################################################################
                            while(boucle_larg < @larg)
                                while(boucle_long < @long)
                                    point_dep_surplan = [@point_depart[0] + boucle_long + @offset_plancher, @point_depart[1] + boucle_larg + @offset_plancher, @point_depart[2] + @hauteur_report ]
                                    trans = Geom::Transformation.new point_dep_surplan
                                    instance = entities.add_instance @componentdefinition, trans
                                    instance.layer = calque
                                    (@groupage) ? (@ss = @selection.add group_comp) : (@ss = @selection.add instance)
                                              if(boucle_long + @long_planche_sur >= @long - (2 *  @offset_plancher)) # Decoupe des dalles de fin sur la longueur fin de boucle longueur##################
                                                    part_long_coupe = (boucle_long + @long_planche_sur) - (@long - (2 *  @offset_plancher))
                                                    long_fin = @long_planche_sur - part_long_coupe
                                                    coef_long = long_fin / @long_planche_sur
                                                    (part_long_coupe >  @mini_chute_long) ? (chute_long = part_long_coupe) : (chute_long = @long_planche_sur)
                                                    deport_dep = 0
                                                    long_sauv = chute_long
                                              elsif(@point_depart[0] + boucle_long == 0 ) # Determination de la dalle de debut de ligne############################                   
                                                            if(chute_long - (@mini_chute_long - (((@long - (2 *  @offset_plancher))- chute_long) % @long_planche_sur )) == long_sauv) # teste si joint face a face                                                             
                                                                  chute_long = @long_planche_sur / 2
                                                                  coef_long = chute_long / @long_planche_sur
                                                                  deport_dep = @long_planche_sur - chute_long                                                             
                                                            else
                                                               chute_long = chute_long - (@mini_chute_long - (((@long - (2 *  @offset_plancher))- chute_long) % @long_planche_sur )) if ((((@long - (2 *  @offset_plancher))- chute_long) % @long_planche_sur ) < @mini_chute_long)                                                     
                                                               chute_long = @long_planche_sur if(chute_long < @mini_chute_long)                                                         
                                                              coef_long = chute_long / @long_planche_sur
                                                              deport_dep = @long_planche_sur - chute_long
                                                              chute_long = @long_planche_sur
                         end
                                              else # Dalles intermediaire complete ###########################################################
                                                    coef_long = 1.0
                                                    deport_dep = 0
                                              end

                                              if(boucle_larg + @larg_planche_sur > @larg - (2 *  @offset_plancher)) # Decoupe des dalles sur la largeur fin de boucle largeur###########################
                                                    part_larg_coupe = (boucle_larg + @larg_planche_sur) - (@larg- (2 *  @offset_plancher))
                                                    larg_fin = @larg_planche_sur - part_larg_coupe
                                                    coef_larg = larg_fin / @larg_planche_sur
                                              else #largeur complete
                                                    coef_larg = 1.0
                                              end

                                      etir_comp = Geom::Transformation.scaling point_dep_surplan, coef_long, coef_larg, 1.0
                                      instance.transform!(etir_comp)
                                 boucle_long += (@long_planche_sur - deport_dep )
                                end # fin de boucle longueur
                                boucle_report = boucle_report_sauv
                                boucle_long = 0
                                boucle_larg += @larg_planche_sur
                            end #fin de boucle largeur

                        else # Avec gestion des entraxes#####################################################################################################################
                        UI.messagebox "Partie sans joints sur entraxe"
                        end

                        #@hauteur_report = @hauteur_report + @epais__planche_sur
                        @hauteur_report = 0
                @model.commit_operation
                @mini_chute_long = @mini_chute_sauv
    end
############################################################################################################################################
# Autres modules en attente ################################################################################################################
############################################################################################################################################

    def self.cons_comp
      UI.messagebox "Construction Complete"
    end

    def self.visserie
        UI.messagebox "Visserie"
    end

    def self.plancher_etage
        UI.messagebox "En Construction"

    end

    def self.mur
        UI.messagebox "En Construction"
    end

    def self.toit_combles
        UI.messagebox "En Construction"
    end

    def self.vide_sanitaire
        UI.messagebox "En Construction"
    end

    def self.analyse_comp
        UI.messagebox "En Construction"
    end
# execution des modules
    def self.execute_commande

    end
############################################################################################################################################
# gestion des dialogues ####################################################################################################################
############################################################################################################################################

# Menu choix des composants ################################################################################################################
    def self.menu_module
        @nom_comp = UI.openpanel "Choix de l'element " + @repertoire, "C:\\Program Files\\Google\\Google SketchUp 7\\Components\\Charpente\\" + @repertoire, "*.skp"
        @componentdefinition = @definitions.load @nom_comp
    end
# Menu Plancher RDC ########################################################################################################################
    def self.menu_plancher_RDC
              if(@long == nil || @larg == nil || @long == 0 || @larg == 0)
                  UI.messagebox "Vous devez d'abord saisir \nles dimensions de la base"
                  menu_param_gen
              end
          @ceinture = "false"
          @poutre = "false"
          @etrier = "false"
          @sousplancher = "false"
          @isolant = "false"
          @parevapeur = "false"
          @surplancher = "false"
          @double_ceint = false
          @offset_plancher = 0
          @joint_sur_axe = "false"
          @appui_mini = 3
          my_dialog = UI::WebDialog.new("Plancher RDC", false, "Plancher RDV", 300, 300, 400, 400, true)
          my_dialog.add_action_callback("ceinture") do |web_dialog,action_name1|
                  @ceinture = action_name1
          end
          my_dialog.add_action_callback("double_ceint") do |web_dialog,action_name8|
                  @double_ceint = action_name8
          end
          my_dialog.add_action_callback("poutre") do |web_dialog,action_name2|
                  @poutre = action_name2
          end
          my_dialog.add_action_callback("etrier") do |web_dialog,action_name3|
                  @etrier = action_name3
          end
          my_dialog.add_action_callback("sousplancher") do |web_dialog,action_name4|
                  @sousplancher = action_name4
          end
          my_dialog.add_action_callback("isolant") do |web_dialog,action_name5|
                  @isolant = action_name5
          end
          my_dialog.add_action_callback("parevapeur") do |web_dialog,action_name6|
                  @parevapeur = action_name6
          end
          my_dialog.add_action_callback("surplancher") do |web_dialog,action_name7|
                  @surplancher = action_name7
          end
        my_dialog.add_action_callback("offset_plancher") do |web_dialog,action_name9|
                  @offset_plancher = action_name9
                  @offset_plancher = separateur_conv (@offset_plancher)
                  @offset_plancher = Sketchup.parse_length @offset_plancher
          end
          my_dialog.add_action_callback("appui_mini") do |web_dialog,action_name10|
                  @appui_mini = action_name10
                  @appui_mini = @appui_mini.to_i
          end
            my_dialog.add_action_callback("joint_sur_axe") do |web_dialog,action_name11|
                  @joint_sur_axe = action_name11
          end

          my_dialog.add_action_callback("executer") do |web_dialog,action_name|plancher_rdc
          end
          my_dialog.add_action_callback("annuler") do |web_dialog,action_name00|
          annulation = Sketchup.send_action("editUndo:")

          end
          my_dialog.add_action_callback("retablir") do |web_dialog,action_name00|
          retablir = Sketchup.send_action("editRedo:")

          end
          my_dialog.add_action_callback("quitter") do |web_dialog,action_name0|web_dialog.close

          end

          html_path = Sketchup.find_support_file "PlancherRDC.html" ,"Plugins"
          my_dialog.set_file(html_path)
          my_dialog.show()

    end
## Menu Parametres generaux ##############################################################################################
    def self.menu_param_gen
          @long = 0
          @larg = 0
          @mini_chute_long = 0
          @entraxe = 0
          @groupage = false
          @sur_calque = false
          @group_global = false

          my_dialog = UI::WebDialog.new("Parametres Generaux", false, "Parametres Generaux", 300, 300, 400, 400, true)

          my_dialog.add_action_callback("valider") do |web_dialog,action_name0|web_dialog.close

          end
          my_dialog.add_action_callback("longueur") do |web_dialog,action_name1|
                  @long = action_name1
                  @long = separateur_conv (@long)
                  @long = Sketchup.parse_length @long
          end
          my_dialog.add_action_callback("largeur") do |web_dialog,action_name2|
                  @larg = action_name2
                  @larg = separateur_conv (@larg)
                  @larg = Sketchup.parse_length @larg
          end
          my_dialog.add_action_callback("entraxe") do |web_dialog,action_name3|
                  @entraxe = action_name3
                  @entraxe = separateur_conv (@entraxe)
                  @entraxe = Sketchup.parse_length @entraxe

          end
          my_dialog.add_action_callback("chute") do |web_dialog,action_name4|
                  @mini_chute_long = action_name4
                  @mini_chute_long = separateur_conv (@mini_chute_long)
                  @mini_chute_long = Sketchup.parse_length @mini_chute_long
                  @mini_chute_long = 0 if(@mini_chute_long == "")
          end
          my_dialog.add_action_callback("quitter") do |web_dialog,action_name0|web_dialog.close

          end
          my_dialog.add_action_callback("groupage") do |web_dialog,action_name01|
                  @groupage = action_name01
          end
          my_dialog.add_action_callback("sur_calque") do |web_dialog,action_name02|
                  @sur_calque = action_name02
          end
          my_dialog.add_action_callback("group_global") do |web_dialog,action_name03|
                  @group_global = action_name03
          end

          html_path = Sketchup.find_support_file "Param_Gen.html" ,"Plugins"
          my_dialog.set_file(html_path)
          my_dialog.show()

    end
## Chargement du menu ####################################################################################################

    def self.chargement_woodstock

          add_separator_to_menu("Plugins")
              testmenu = UI.menu("Plugins").add_submenu("Construction Bois")
              cmd = []
              cmd[0] = UI::Command.new("Parametres generaux") { self.menu_param_gen }
              cmd[1] = UI::Command.new("Construction Complete") { self.cons_comp }
              cmd[2] = UI::Command.new("Plancher RDC") { self.menu_plancher_RDC }
              cmd[3] = UI::Command.new("Plancher Etage") { self.plancher_etage }
              cmd[4] = UI::Command.new("Mur") { self.mur}
              cmd[5] = UI::Command.new("Toit & Combles") { self.toit_combles }
              cmd[6] = UI::Command.new("Vide sanitaire") { self.vide_sanitaire }
              cmd[7] = UI::Command.new("Analyse complémentaires") { self.analyse_comp }
              cmd.each do |e| testmenu.add_item(e); end
    end

if !file_loaded? File.basename(__FILE__)
  chargement_woodstock
  file_loaded File.basename(__FILE__)
end

end # FIn du module

geoxien a écrit:Bien d'accord sinon cela va devenir une usine à gaz difficilement maintenable ou difficile à faire évoluer

de plus au moins trois appuis si osb rainuré ,c'est juste le minimum qui est demandé ,ensuite chacun fait comme il veut ou selon
les contraintes du chantier tout en respectant le minimum, c'est valable pour tous les points techniques de la contruction.

Bon courage

Sebdhem a écrit:

geoxien a écrit:Bien d'accord sinon cela va devenir une usine à gaz difficilement maintenable ou difficile à faire évoluer

de plus au moins trois appuis si osb rainuré ,c'est juste le minimum qui est demandé ,ensuite chacun fait comme il veut ou selon
les contraintes du chantier tout en respectant le minimum, c'est valable pour tous les points techniques de la contruction.

Bon courage

Geoxien avait marqué trois... de toute manière, si je ne dis pas de grosse connerie, en les mettant perpendiculaires aux poutres, les dalles d'OSB reposent sur plus de trois appuis en règle générale...

geoxien a écrit:Bonjour

Pour ma part comme déjà dit quelques pages avant,si rainuré les panneaux doivent juste poser sur 3 appuis .
Il n' y a donc pas pour moi obligation de tomber toujours sur les solives.

Bon maintenant ce ne sont pas juste des planchers ,ce sont des contreventements horizontaux, donc fait-on le moins ou le plus ?

Sebdhem a écrit:oui j'avais bien compris... donc je reformule aussi : si rainurés même si la rainure tombe sur une poutre : 3 appuis... c'est mon interprétation...

ga a écrit:_Certaines préconisations du fabriquant sont infaisables ...

ga a écrit:_Ce cas très réaliste , dont c.plassais à soulevé et que tu as réglé Sebdhem en 3 coups de cuillères à pot , me fais penser à un post 2 pages auparavant :

ga a écrit:_Certaines préconisations du fabriquant sont infaisables ...

Pas bête le ga

"bravo les hommes en bleu"
Voilas ca c'est dit .......

c.plassais a écrit:Dernière version du module plancher RDC

Le plugin est maintenant crypté en rbs, mais cela n'affecte pas son fonctionnement
Je le transmets par MP

c.plassais

1. Ceinture
   
2. Solives
   
3. Etriers
   
4. Dalle du dessous
   
5. Isolant
   
6. Pare-vapeur
   
7. Dalle du dessus