├── pyApex.tab
    ├── lib
    │   ├── __init__.py
    │   ├── pyapex_utils.py
    │   └── curve_chain.py
    ├── Misc.panel
    │   ├── icon.png
    │   ├── bundle.yaml
    │   ├── Purge.pulldown
    │   │   ├── icon.png
    │   │   ├── PurgeFamilies.pushbutton
    │   │   │   ├── icon.png
    │   │   │   ├── lib
    │   │   │   │   └── purge_families_defaults.py
    │   │   │   ├── PurgeFamiliesConfig.xaml
    │   │   │   └── config.py
    │   │   └── TagsDuplicates.pushbutton
    │   │   │   ├── icon.png
    │   │   │   ├── switches
    │   │   │   └── script.py
    │   ├── ShowDependent.pushbutton
    │   │   ├── icon.png
    │   │   ├── lib
    │   │   │   └── show_dependent_defaults.py
    │   │   ├── ShowDependentConfig.xaml
    │   │   ├── config.py
    │   │   └── script.py
    │   ├── utils3.stack
    │   │   ├── LinkMore.pushbutton
    │   │   │   ├── icon.png
    │   │   │   └── script.py
    │   │   ├── CopyBtwDocs.pushbutton
    │   │   │   ├── icon.png
    │   │   │   └── script.py
    │   │   └── LinkDWGsite.pushbutton
    │   │   │   ├── icon.png
    │   │   │   └── script.py
    │   ├── utils2.stack
    │   │   ├── ReplaceText.pushbutton
    │   │   │   ├── icon.png
    │   │   │   ├── window.xaml
    │   │   │   └── script.py
    │   │   ├── CopyParameter.pushbutton
    │   │   │   ├── icon.png
    │   │   │   ├── window.xaml
    │   │   │   └── script.py
    │   │   └── SumParameter.pushbutton
    │   │   │   ├── icon.png
    │   │   │   ├── window.xaml
    │   │   │   └── script.py
    │   ├── utils4.stack
    │   │   ├── SelectGroup.pushbutton
    │   │   │   ├── icon.png
    │   │   │   └── script.py
    │   │   ├── ExcludeGrouped.pushbutton
    │   │   │   ├── icon.png
    │   │   │   └── script.py
    │   │   └── SaveFamilies.pushbutton
    │   │   │   ├── icon.png
    │   │   │   └── SaveFamilies_script.py
    │   └── utils.stack
    │   │   ├── WhiteMaterials.pushbutton
    │   │       ├── icon.png
    │   │       ├── lib
    │   │       │   └── white_materials_defaults.py
    │   │       ├── WhiteMaterialsConfig.xaml
    │   │       ├── config.py
    │   │       └── script.py
    │   │   └── SortAndEnumerate.pushbutton
    │   │       ├── icon.png
    │   │       ├── window.xaml
    │   │       └── script.py
    ├── bundle.yaml
    ├── Model.panel
    │   ├── Level.pulldown
    │   │   ├── icon.png
    │   │   └── RemoveLevel.pushbutton
    │   │   │   ├── icon.png
    │   │   │   └── script.py
    │   ├── UnjoinSelected.pushbutton
    │   │   ├── icon.png
    │   │   └── script.py
    │   └── DisableConstraints.pushbutton
    │   │   ├── icon.png
    │   │   └── script.py
    ├── Detail.panel
    │   ├── FlipGridEnds.pushbutton
    │   │   ├── icon.png
    │   │   └── script.py
    │   ├── Copy_VG_Filters.pushbutton
    │   │   ├── icon.png
    │   │   └── script.py
    │   └── TextNotes2csv.pushbutton
    │   │   ├── icon.png
    │   │   └── script.py
    ├── QualityControl.panel
    │   ├── Links.pushbutton
    │   │   ├── icon.png
    │   │   └── script.py
    │   ├── GridAngle.pushbutton
    │   │   ├── icon.png
    │   │   └── script.py
    │   └── GridDistance.pushbutton
    │   │   ├── icon.png
    │   │   └── GridDistance_script.py
    ├── Selection.panel
    │   └── sel1.stack
    │   │   ├── OpenViews.pushbutton
    │   │       ├── icon.png
    │   │       └── script.py
    │   │   ├── ZoomBasePoint.pushbutton
    │   │       ├── icon.png
    │   │       └── script.py
    │   │   └── ExtractIdsText.pushbutton
    │   │       ├── icon.png
    │   │       ├── window.xaml
    │   │       └── script.py
    └── WIP.panel
    │   └── CopyParameterTest.pushbutton
    │       └── script.py
├── .gitignore
└── README.md


/pyApex.tab/lib/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/bundle.yaml:
--------------------------------------------------------------------------------
1 | layout:
2 |   - Selection
3 |   - Model
4 |   - Detail
5 |   - Misc
6 |   - QualityControl
7 |   - WIP
8 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/bundle.yaml:
--------------------------------------------------------------------------------
1 | layout:
2 |   - utils
3 |   - utils2
4 |   - utils3
5 |   - utils4
6 |   - ShowDependent
7 |   - Purge
8 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/Purge.pulldown/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/Purge.pulldown/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Model.panel/Level.pulldown/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Model.panel/Level.pulldown/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Detail.panel/FlipGridEnds.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Detail.panel/FlipGridEnds.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/ShowDependent.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/ShowDependent.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Detail.panel/Copy_VG_Filters.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Detail.panel/Copy_VG_Filters.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Detail.panel/TextNotes2csv.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Detail.panel/TextNotes2csv.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Model.panel/UnjoinSelected.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Model.panel/UnjoinSelected.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/QualityControl.panel/Links.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/QualityControl.panel/Links.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Model.panel/DisableConstraints.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Model.panel/DisableConstraints.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/QualityControl.panel/GridAngle.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/QualityControl.panel/GridAngle.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils3.stack/LinkMore.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/utils3.stack/LinkMore.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/QualityControl.panel/GridDistance.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/QualityControl.panel/GridDistance.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils2.stack/ReplaceText.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/utils2.stack/ReplaceText.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils3.stack/CopyBtwDocs.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/utils3.stack/CopyBtwDocs.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils3.stack/LinkDWGsite.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/utils3.stack/LinkDWGsite.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils4.stack/SelectGroup.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/utils4.stack/SelectGroup.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils.stack/WhiteMaterials.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/utils.stack/WhiteMaterials.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils2.stack/CopyParameter.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/utils2.stack/CopyParameter.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils2.stack/SumParameter.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/utils2.stack/SumParameter.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils4.stack/ExcludeGrouped.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/utils4.stack/ExcludeGrouped.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils4.stack/SaveFamilies.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/utils4.stack/SaveFamilies.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Model.panel/Level.pulldown/RemoveLevel.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Model.panel/Level.pulldown/RemoveLevel.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Selection.panel/sel1.stack/OpenViews.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Selection.panel/sel1.stack/OpenViews.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/Purge.pulldown/PurgeFamilies.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/Purge.pulldown/PurgeFamilies.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/Purge.pulldown/TagsDuplicates.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/Purge.pulldown/TagsDuplicates.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils.stack/SortAndEnumerate.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Misc.panel/utils.stack/SortAndEnumerate.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Selection.panel/sel1.stack/ZoomBasePoint.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Selection.panel/sel1.stack/ZoomBasePoint.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Selection.panel/sel1.stack/ExtractIdsText.pushbutton/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/apex-project/pyApex/HEAD/pyApex.tab/Selection.panel/sel1.stack/ExtractIdsText.pushbutton/icon.png


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/Purge.pulldown/PurgeFamilies.pushbutton/lib/purge_families_defaults.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import tempfile
3 | import os
4 | temp_dir = os.path.join(tempfile.gettempdir(), "pyApex_purgeFamilies")


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils.stack/WhiteMaterials.pushbutton/lib/white_materials_defaults.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import pyapex_utils
3 | exceptions = [
4 |     "Glass",
5 | ]
6 | material = "Default"
7 | ignore_transparent = True
8 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/ShowDependent.pushbutton/lib/show_dependent_defaults.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | 
 3 | exceptions = [
 4 |     "Levels",
 5 |     "Work Plane Grid",
 6 |     "Viewports",
 7 |     "Other",
 8 |     "Sun Path",
 9 |     "Automatic Sketch Dimensions",
10 |     "<Sketch>",
11 |     "<Area Boundary>",
12 |     "Constraints",
13 | ]
14 | 
15 | limit = 10
16 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils4.stack/ExcludeGrouped.pushbutton/script.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | __title__ = 'Exclude Grouped'
 3 | __doc__ = """Exclude grouped elements from selection
 4 | 
 5 | Shift+Click - isolate grouped elements"""
 6 | __context__ = 'Selection'
 7 | __helpurl__ = "https://apex-project.github.io/pyApex/help#exclude-grouped"
 8 | 
 9 | from pyrevit import revit
10 | selection = revit.get_selection()
11 | 
12 | def filter_grouped(e, inverse = False):
13 |     if inverse:
14 |         return e.GroupId.IntegerValue != -1
15 |     else:
16 |         return e.GroupId.IntegerValue == -1
17 | 
18 | if __name__ == '__main__':
19 |     sel = selection.elements
20 |     sel = list(filter(lambda e: filter_grouped(e, __shiftclick__), sel))
21 |     selection.set_to(sel)
22 | 


--------------------------------------------------------------------------------
/pyApex.tab/lib/pyapex_utils.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | def filter_list(l):
 3 |     l = filter(lambda x: len(x) > 0, l)
 4 |     l = map(lambda x: x.strip("\n").strip("\n").strip("\r"), l)
 5 |     return l
 6 | 
 7 | 
 8 | def list2str(l):
 9 |     """"""
10 | 
11 |     """back compatibility START"""
12 |     if type(l) != list:
13 |         l = str2list(l)
14 |     """back compatibility END"""
15 | 
16 |     l = filter_list(l)
17 |     return "\n".join(l)
18 | 
19 | 
20 | def str2list(s):
21 |     l = s.split("\n")
22 | 
23 |     """back compatibility START"""
24 |     # remove empty rows
25 |     l = filter_list(l)
26 |     # check is separator is ',' - not '\n'
27 |     if len(l) == 1:
28 |         if "," in l[0]:
29 |             l = l[0].split(",")
30 |             l = filter(lambda x: len(x) > 0, l)
31 |     """back compatibility END"""
32 | 
33 |     l = filter_list(l)
34 | 
35 |     return l
36 | 
37 | 
38 | def compare_xyz(xyz1, xyz2, precision = None):
39 |     if precision != None:
40 |         return round(xyz1.X, precision) == round(xyz2.X, precision) \
41 |                and round(xyz1.Y, precision) == round(xyz2.Y, precision) \
42 |                and round(xyz1.Z, precision) == round(xyz2.Z, precision)
43 |     else:
44 |         return xyz1.X == xyz2.X and xyz1.Y == xyz2.Y and xyz1.Z == xyz2.Z
45 | 
46 | def is_ascii(s):
47 |     return all(ord(c) < 128 for c in s)
48 | 
49 | def almost_equal(x, y, rnd=10):
50 |     return round(x*(10^rnd)) == round(y*(10^rnd))


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils2.stack/ReplaceText.pushbutton/window.xaml:
--------------------------------------------------------------------------------
 1 | <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 2 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 3 |         Title="Replace text:" Height="220" Width="400" ShowInTaskbar="False" ResizeMode="NoResize"
 4 |         WindowStartupLocation="CenterScreen" ScrollViewer.VerticalScrollBarVisibility="Disabled" HorizontalContentAlignment="Center">
 5 |     <Grid Margin="20">
 6 |         <Grid.RowDefinitions>
 7 |             <RowDefinition Height="50"/>
 8 |             <RowDefinition Height="50"/>
 9 |             <RowDefinition Height="*"/>
10 |             <RowDefinition Height="auto" MinHeight="20"/>
11 |         </Grid.RowDefinitions>
12 | 
13 |         <StackPanel Grid.Row="0" Margin="0,0,0,0">
14 |             <Label x:Name="label01" Content="Find:" HorizontalAlignment="Left" VerticalAlignment="Top"/>
15 |             <TextBox x:Name="textFind" HorizontalAlignment="Stretch" Height="23" VerticalAlignment="Top"/>
16 |         </StackPanel>
17 | 
18 |         <StackPanel Grid.Row="1" Margin="0,0,0,0">
19 |             <Label x:Name="label02" Content="Replace:" HorizontalAlignment="Left" VerticalAlignment="Top"/>
20 |             <TextBox x:Name="textReplace" HorizontalAlignment="Stretch" Height="23" VerticalAlignment="Top"/>
21 |         </StackPanel>
22 | 
23 |         <Button Grid.Row="3" Grid.ColumnSpan="5" Margin="0,15,0,0" Click="run" Content="Replace" />
24 |     </Grid>
25 | </Window>
26 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/Purge.pulldown/PurgeFamilies.pushbutton/PurgeFamiliesConfig.xaml:
--------------------------------------------------------------------------------
 1 | <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 2 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 3 |         Title="Options for Purge Families" MinHeight="230" Height="230" MaxHeight="220" MinWidth="400" MaxWidth="1000" Width="400" ShowInTaskbar="True" ResizeMode="CanResizeWithGrip"
 4 |         WindowStartupLocation="CenterScreen" ScrollViewer.VerticalScrollBarVisibility="Disabled" HorizontalContentAlignment="Center">
 5 |     <Grid Margin="20">
 6 |         <Grid.RowDefinitions>
 7 |             <RowDefinition Height="auto" />
 8 |             <RowDefinition Height="auto" />
 9 |             <RowDefinition Height="*" />
10 |             <RowDefinition Height="auto" />
11 |             <RowDefinition Height="auto" />
12 |         </Grid.RowDefinitions>
13 | 
14 |         <Label x:Name="label2" Content="Pick folder to save families backup files and report"  Grid.Row="0"/>
15 |         <TextBox x:Name="temp_dir" Height="23" HorizontalAlignment="Stretch" Grid.Row="1" />
16 |         <Button Grid.Row="2" Margin="0,10,0,0" Click="pick" Content="Pick folder" HorizontalAlignment="Left" VerticalAlignment="Top" Width="150"  Height="22"/>
17 |         <Button Grid.Row="3" Margin="0,10,0,0" Click="restore_defaults" Content="Defaults" HorizontalAlignment="Right" Width="100"/>
18 |         <Button Grid.Row="4" Margin="0,10,0,0" Click="save_options" Content="Save options" />
19 | 
20 |     </Grid>
21 | </Window>
22 | 


--------------------------------------------------------------------------------
/pyApex.tab/Selection.panel/sel1.stack/ExtractIdsText.pushbutton/window.xaml:
--------------------------------------------------------------------------------
 1 | <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 2 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 3 |         Title="Extract IDs from text:" MinHeight="300" MinWidth="400" Height="300" Width="400" ShowInTaskbar="True"
 4 |         WindowStartupLocation="CenterScreen" ScrollViewer.VerticalScrollBarVisibility="Disabled" HorizontalContentAlignment="Center">
 5 |     <Grid Margin="20,5,20,20">
 6 |         <Grid.RowDefinitions>
 7 |             <RowDefinition Height="25"/>
 8 |             <RowDefinition Height="*" MinHeight="60"/>
 9 |             <RowDefinition Height="auto" MinHeight="20"/>
10 |             <RowDefinition Height="auto" MinHeight="40"/>
11 |         </Grid.RowDefinitions>
12 |         <StackPanel Grid.Row="0" Margin="0,0,0,0">
13 |             <Label x:Name="label" Content="Input text:" HorizontalAlignment="Left" VerticalAlignment="Top"/>
14 | 
15 |         </StackPanel>
16 |         <TextBox Grid.Row="1" x:Name="text" TextWrapping="Wrap" Text="TextBox" AcceptsReturn="True"/>
17 |         <StackPanel Grid.Row="2" Margin="0,5,0,0" Grid.RowSpan="2">
18 |             <CheckBox Margin="0,0,10,0" x:Name="reduce_duplicates" Content="Reduce duplicates"/>
19 |         </StackPanel>
20 |         <!--<TextBlock Text="{Binding VersionNumber}" Padding="3" TextWrapping="Wrap" HorizontalAlignment="Center" FontSize="15" Margin="224,0,223.6,41.4" Grid.RowSpan="2" Width="6"/>-->
21 |         <Button Grid.Row="3" Margin="0,20,0,0" Click="send" Content="Extract IDs"/>
22 |     </Grid>
23 | </Window>
24 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/Purge.pulldown/TagsDuplicates.pushbutton/switches:
--------------------------------------------------------------------------------
 1 | OST_RoomTags
 2 | OST_AreaTags
 3 | OST_DoorTags
 4 | OST_WindowTags
 5 | 
 6 | OST_PartTags
 7 | OST_AssemblyTags
 8 | OST_RoofTags
 9 | OST_StairsRailingTags
10 | OST_StairsTags
11 | OST_MaterialTags
12 | OST_CurtaSystemTags
13 | OST_HostFinTags
14 | OST_StairsTags
15 | OST_MultiCategoryTags
16 | OST_PlantingTags
17 | OST_ParkingTags
18 | OST_SiteTags
19 | OST_GenericModelTags
20 | OST_CurtainWallPanelTags
21 | OST_WallTags
22 | OST_GenericModelTags
23 | OST_CurtainWallPanelTags
24 | OST_FurnitureTags
25 | OST_ElectricalFixtureTags
26 | OST_ElectricalEquipmentTags
27 | OST_CeilingTags
28 | OST_CaseworkTags
29 | OST_Tags
30 | OST_MassTags
31 | OST_MassAreaFaceTags
32 | 
33 | OST_FoundationSlabAnalyticalTags
34 | OST_WallFoundationAnalyticalTags
35 | OST_IsolatedFoundationAnalyticalTags
36 | OST_WallAnalyticalTags
37 | OST_FloorAnalyticalTags
38 | OST_ColumnAnalyticalTags
39 | OST_BraceAnalyticalTags
40 | OST_BeamAnalyticalTags
41 | OST_FabricAreaTags
42 | OST_FabricReinforcementTags
43 | OST_AreaReinTags
44 | OST_RebarTags
45 | OST_StructConnectionTags
46 | OST_PathReinTags
47 | OST_FabricationPartTags
48 | 
49 | OST_PipeInsulationsTags
50 | OST_DuctLiningsTags
51 | OST_DuctInsulationsTags
52 | OST_CableTrayTags
53 | OST_ConduitFittingTags
54 | OST_CableTrayFittingTags
55 | OST_ZoneTags
56 | OST_SprinklerTags
57 | OST_LightingDeviceTags
58 | OST_FireAlarmDeviceTags
59 | OST_FireAlarmDevices
60 | OST_DataDeviceTags
61 | OST_CommunicationDeviceTags
62 | OST_SecurityDeviceTags
63 | OST_NurseCallDeviceTags
64 | OST_TelephoneDeviceTags
65 | OST_MEPSpaceTags


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils2.stack/CopyParameter.pushbutton/window.xaml:
--------------------------------------------------------------------------------
 1 | <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 2 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 3 |         Title="Copy parameter values:" Height="225" Width="400" ShowInTaskbar="False" ResizeMode="NoResize"
 4 |         WindowStartupLocation="CenterScreen" ScrollViewer.VerticalScrollBarVisibility="Disabled" HorizontalContentAlignment="Center">
 5 |     <Grid Margin="20">
 6 |         <Grid.RowDefinitions>
 7 |             <RowDefinition Height="50"/>
 8 |             <RowDefinition Height="60"/>
 9 |             <RowDefinition Height="*"/>
10 |             <RowDefinition Height="auto" MinHeight="20"/>
11 |         </Grid.RowDefinitions>
12 | 
13 | 
14 |         <StackPanel Grid.Row="0" Margin="0,0,0,0">
15 |             <Label x:Name="label01" Content="Get value from:" HorizontalAlignment="Left" VerticalAlignment="Top"/>
16 |             <ComboBox x:Name="parameterToGet" HorizontalAlignment="Stretch" VerticalAlignment="Top" IsEditable="True"
17 |                       StaysOpenOnEdit="True"/>
18 |         </StackPanel>
19 | 
20 |         <StackPanel Grid.Row="1" Margin="0,0,0,0">
21 |             <Label x:Name="label02" Content="Set value to:" HorizontalAlignment="Left" VerticalAlignment="Top"/>
22 |             <ComboBox x:Name="parameterToSet" HorizontalAlignment="Stretch" VerticalAlignment="Top" IsEditable="True"
23 |                       StaysOpenOnEdit="True"/>
24 |         </StackPanel>
25 | 
26 |         <Button Grid.Row="3" Grid.ColumnSpan="5" Margin="0,15,0,0" Click="run" Content="Copy value" />
27 |     </Grid>
28 | </Window>
29 | 


--------------------------------------------------------------------------------
/pyApex.tab/Selection.panel/sel1.stack/OpenViews.pushbutton/script.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*- 
 2 | __title__ = 'Open Views'
 3 | __doc__ = """To save time for rendering each view, this button opens all selected views in one click
 4 | Context: Some views should be selected
 5 | 
 6 | Чтобы сэкономить время, которое тратится на рендеринг при открытии вида, эта кнопка открывает несколько выделенных видов одним нажатием.
 7 | Контекст: Должны быть выбраны несколько видов в браузере проекта или на листе"""
 8 | __context__ = 'Selection'
 9 | 
10 | try:
11 |     from pyrevit.versionmgr import PYREVIT_VERSION
12 | except:
13 |     from pyrevit import versionmgr
14 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
15 | 
16 | pyRevitNewer44 = PYREVIT_VERSION.major >=4 and PYREVIT_VERSION.minor >=5
17 | 
18 | if pyRevitNewer44:
19 |     from pyrevit import revit
20 |     selection = revit.get_selection()
21 |     uidoc = revit.uidoc
22 | else:
23 |     from revitutils import selection, uidoc
24 | 
25 | from Autodesk.Revit.UI import TaskDialog
26 | 
27 | __helpurl__ = "https://github.com/apex-project/pyApex/wiki/Buttons#open-views"
28 | 
29 | sel = selection.elements
30 | sel_count = len(sel)
31 | 
32 | errors = 0
33 | for v in sel:
34 |     try:
35 |         uidoc.ActiveView = v
36 |     except:
37 |         errors += 1
38 | 
39 | # Show message if error occured or nothing selected
40 | if sel_count == 0:
41 |     TaskDialog.Show(__title__, "Select views to open")
42 | elif errors == sel_count:
43 |     TaskDialog.Show(__title__, "Unable to open selected views")
44 | elif errors != 0:
45 |     TaskDialog.Show(__title__, "%d of %d selected views were opened" % (sel_count - errors, sel_count))


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils4.stack/SelectGroup.pushbutton/script.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | __title__ = 'Select top group'
 3 | __doc__ = """Select group instances, which contains selected elements. 
 4 | By default excludes not grouped elements from selection
 5 | 
 6 | Shift+Click: include not grouped elements"""
 7 | __context__ = 'Selection'
 8 | __helpurl__ = "https://apex-project.github.io/pyApex/help#exclude-grouped"
 9 | 
10 | from pyrevit import revit, script
11 | selection = revit.get_selection()
12 | logger = script.get_logger()
13 | 
14 | def get_higher_group(doc, element):
15 |     logger.debug("get_higher_group: Process id %d" % element.Id.IntegerValue)
16 |     if element.GroupId.IntegerValue != -1:
17 |         logger.debug("get_higher_group: element is grouped. GroupId=%d" % element.GroupId.IntegerValue)
18 |         group = doc.GetElement(element.GroupId)
19 |         logger.debug("get_higher_group: groupd=%s" % str(group))
20 |         return get_higher_group(doc, group)
21 |     else:
22 |         logger.debug("get_higher_group: element not grouped")
23 |         return element
24 | 
25 | if __name__ == '__main__':
26 |     sel = selection.elements
27 |     doc = revit.doc
28 | 
29 |     ids_to_select = set()
30 |     elements_to_select = []
31 | 
32 |     for e in sel:
33 |         if e.GroupId.IntegerValue != -1: # leave only groupped elements
34 |             higher_group = get_higher_group(doc, e)
35 |             ids_to_select.add(higher_group.Id)
36 |         else:
37 |             if __shiftclick__:
38 |                 elements_to_select.append(e.Id)
39 | 
40 |     elements_to_select += map(lambda e_id: doc.GetElement(e_id), ids_to_select)
41 |     selection.set_to(elements_to_select)
42 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils4.stack/SaveFamilies.pushbutton/SaveFamilies_script.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | __title__ = "Save families"
 3 | __doc__ = """Saves chosen families from the project
 4 | 
 5 | 1. Run the script.
 6 | 2. Choose families from the list.
 7 | 3. Pick a folder to save the families
 8 | 
 9 | Voila!
10 | """
11 | 
12 | from pyrevit import revit, script, DB, forms
13 | import os.path as op
14 | selection = revit.get_selection()
15 | logger = script.get_logger()
16 | 
17 | def get_families(doc):
18 |     cl = DB.FilteredElementCollector(doc)
19 | 
20 |     families_types = set(cl.WhereElementIsElementType().ToElements())
21 |     families = []
22 |     for f in families_types:
23 |         if type(f) == DB.FamilySymbol or type(f) == DB.AnnotationSymbolType:
24 |             families.append(f.Family)
25 | 
26 |     return families
27 | 
28 | 
29 | if __name__ == '__main__':
30 |     sel = selection.elements
31 |     doc = revit.doc
32 |     
33 |     fam_dict = {}
34 |     for f in get_families(doc):
35 |         if f.FamilyCategory:
36 |             fam_dict["%s: %s" % (f.FamilyCategory.Name, f.Name)] = f
37 |         
38 |     fam_selected = forms.SelectFromList.show(sorted(fam_dict.keys()), title="Save famiiles", multiselect=True)
39 |     if not fam_selected:
40 |         script.exit()
41 |     fam_selected = map(lambda f: fam_dict[f], fam_selected)
42 |     if not fam_selected:
43 |         script.exit()
44 |     folder = forms.pick_folder()
45 |     if not folder:
46 |         script.exit()
47 |     for fam in fam_selected:
48 |         print("Saving %s ..." % fam.Name)
49 |         fam_doc = doc.EditFamily(fam)
50 |         fam_doc.SaveAs(op.join(folder, fam.Name + ".rfa"))
51 |         fam_doc.Close(False)


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | .idea/
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | env/
 12 | build/
 13 | develop-eggs/
 14 | dist/
 15 | downloads/
 16 | eggs/
 17 | .eggs/
 18 | lib64/
 19 | parts/
 20 | sdist/
 21 | var/
 22 | wheels/
 23 | *.egg-info/
 24 | .installed.cfg
 25 | *.egg
 26 | 
 27 | # PyInstaller
 28 | #  Usually these files are written by a python script from a template
 29 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 30 | *.manifest
 31 | *.spec
 32 | 
 33 | # Installer logs
 34 | pip-log.txt
 35 | pip-delete-this-directory.txt
 36 | 
 37 | # Unit test / coverage reports
 38 | htmlcov/
 39 | .tox/
 40 | .coverage
 41 | .coverage.*
 42 | .cache
 43 | nosetests.xml
 44 | coverage.xml
 45 | *.cover
 46 | .hypothesis/
 47 | 
 48 | # Translations
 49 | *.mo
 50 | *.pot
 51 | 
 52 | # Django stuff:
 53 | *.log
 54 | local_settings.py
 55 | 
 56 | # Flask stuff:
 57 | instance/
 58 | .webassets-cache
 59 | 
 60 | # Scrapy stuff:
 61 | .scrapy
 62 | 
 63 | # Sphinx documentation
 64 | docs/_build/
 65 | 
 66 | # PyBuilder
 67 | target/
 68 | 
 69 | # Jupyter Notebook
 70 | .ipynb_checkpoints
 71 | 
 72 | # pyenv
 73 | .python-version
 74 | 
 75 | # celery beat schedule file
 76 | celerybeat-schedule
 77 | 
 78 | # SageMath parsed files
 79 | *.sage.py
 80 | 
 81 | # dotenv
 82 | .env
 83 | 
 84 | # virtualenv
 85 | .venv
 86 | venv/
 87 | ENV/
 88 | 
 89 | # Spyder project settings
 90 | .spyderproject
 91 | .spyproject
 92 | 
 93 | # Rope project settings
 94 | .ropeproject
 95 | 
 96 | # mkdocs documentation
 97 | /site
 98 | 
 99 | # mypy
100 | .mypy_cache/
101 | 
102 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/ShowDependent.pushbutton/ShowDependentConfig.xaml:
--------------------------------------------------------------------------------
 1 | <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 2 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 3 |         Title="Options for Show Dependencies" MinHeight="400" Height="400" MinWidth="300" MaxWidth="600" Width="300" ShowInTaskbar="True" ResizeMode="CanResizeWithGrip"
 4 |         WindowStartupLocation="CenterScreen" ScrollViewer.VerticalScrollBarVisibility="Disabled" HorizontalContentAlignment="Center">
 5 |     <Grid Margin="20">
 6 |         <Grid.RowDefinitions>
 7 |             <RowDefinition Height="auto"/>
 8 |             <RowDefinition Height="*"/>
 9 |             <RowDefinition Height="auto" />
10 |             <RowDefinition Height="auto" />
11 |             <RowDefinition Height="auto" />
12 |             <RowDefinition Height="auto" />
13 |         </Grid.RowDefinitions>
14 | 
15 |         <Label x:Name="label1" Grid.Row="0" Grid.ColumnSpan="3">
16 |             <TextBlock TextWrapping="WrapWithOverflow">
17 |                         List of types exceptions<LineBreak/>
18 |                         (one element type name per line)
19 |             </TextBlock>
20 |         </Label>
21 |         <TextBox x:Name="exceptions" HorizontalAlignment="Stretch" Grid.Row="1" Grid.ColumnSpan="3" TextWrapping="Wrap"
22 |                  Text="TextBox" AcceptsReturn="True" VerticalAlignment="Stretch"/>
23 | 
24 |         <Label x:Name="label2" Content="Limit of IDs to show (0 = show types only)" Margin="0,5,0,0"  Grid.Row="2"/>
25 |         <TextBox x:Name="limit" Height="23" Width="100" HorizontalAlignment="Left" TextWrapping="Wrap" Text="0"
26 |                  PreviewTextInput="NumberValidationTextBox" Grid.Row="3" />
27 |         <Button Grid.Row="4" Margin="0,10,0,0" Click="restore_defaults" Content="Defaults" HorizontalAlignment="Right" Width="100"/>
28 |         <Button Grid.Row="5" Margin="0,10,0,0" Click="save_options" Content="Save options" />
29 | 
30 |     </Grid>
31 | </Window>
32 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils.stack/WhiteMaterials.pushbutton/WhiteMaterialsConfig.xaml:
--------------------------------------------------------------------------------
 1 | <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 2 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 3 |         Title="Options for White Materials" MinHeight="300" Height="400" MinWidth="300" MaxWidth="600" Width="300" ShowInTaskbar="True" ResizeMode="CanResizeWithGrip"
 4 |         WindowStartupLocation="CenterScreen" ScrollViewer.VerticalScrollBarVisibility="Disabled" HorizontalContentAlignment="Center">
 5 |     <Grid Margin="20">
 6 |         <Grid.RowDefinitions>
 7 |             <RowDefinition Height="auto"/>
 8 |             <RowDefinition Height="auto" />
 9 |             <RowDefinition Height="auto" />
10 |             <RowDefinition Height="*"/>
11 |             <RowDefinition Height="auto" />
12 |             <RowDefinition Height="auto" />
13 |             <RowDefinition Height="auto" />
14 |         </Grid.RowDefinitions>
15 |         <Label x:Name="label2" Grid.Row="0" Content="Change to material" />
16 |         <TextBox x:Name="material" Height="23" HorizontalAlignment="Stretch" TextWrapping="Wrap" Text="" Grid.Row="1"/>
17 |         <Label x:Name="label1" Grid.Row="2">
18 |             <TextBlock TextWrapping="WrapWithOverflow">
19 |                         List of materials exceptions<LineBreak/>
20 |                         (one material name per line)
21 |             </TextBlock>
22 |         </Label>
23 |         <TextBox x:Name="exceptions" HorizontalAlignment="Stretch" Grid.Row="3" TextWrapping="Wrap" AcceptsReturn="True" Text="" VerticalAlignment="Stretch"/>
24 |         <CheckBox x:Name="ignore_transparent" Content="Ignore transparent materials" HorizontalAlignment="Left" Margin="0,10,0,0" Grid.Row="4" VerticalAlignment="Top"/>
25 |         <Button Grid.Row="5" Margin="0,10,0,0" Click="restore_defaults" Content="Defaults" HorizontalAlignment="Right" Width="100" />
26 |         <Button Grid.Row="6" Grid.ColumnSpan="5" Margin="0,10,0,0" Click="save_options" Content="Save options" />
27 | 
28 |     </Grid>
29 | </Window>
30 | 


--------------------------------------------------------------------------------
/pyApex.tab/Model.panel/UnjoinSelected.pushbutton/script.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | __title__ = 'Unjoin many'
 3 | 
 4 | __doc__ = """Unjoins all selected geometry. (undo Join command)
 5 | Useful to get rid of warnings "Highlighted Elements are Joined but do not Intersect"
 6 |  Context: Some elements should be selected
 7 | 
 8 | Разъединяет все выбранные элементы. (отменяет команду Соединить)
 9 | Полезно в случаях, когда нужно избавиться от предупреждения "Элементы соединены, но не пересекаются"
10 | Контекст: Должно быть выбрано несколько элементов"""
11 | 
12 | __helpurl__ = "https://apex-project.github.io/pyApex/help#unjoin-many"
13 | 
14 | __context__ = 'Selection'
15 | 
16 | try:
17 |     from pyrevit.versionmgr import PYREVIT_VERSION
18 | except:
19 |     from pyrevit import versionmgr
20 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
21 | 
22 | pyRevitNewer44 = PYREVIT_VERSION.major >=4 and PYREVIT_VERSION.minor >=5
23 | 
24 | if pyRevitNewer44:
25 |     from pyrevit.revit import doc, selection
26 |     selection = selection.get_selection()
27 | else:
28 |     from revitutils import doc, selection
29 | 
30 | selected_ids = selection.element_ids
31 | 
32 | from Autodesk.Revit.DB import BuiltInCategory, ElementId, JoinGeometryUtils, Transaction
33 | from Autodesk.Revit.UI import TaskDialog
34 | 
35 | rng = range(len(selected_ids))
36 | checked_pairs = []
37 | joined_pairs = []
38 | c = 0
39 | 
40 | for x in rng:
41 |     for y in rng:
42 |         if x == y:
43 |             continue
44 |         _p = sorted([x,y])
45 |         _t = (_p[0],_p[1])
46 |         if _t in checked_pairs:
47 |             continue
48 | 
49 |         checked_pairs.append(_t)
50 |         eid1 = selected_ids[_p[0]]
51 |         eid2 = selected_ids[_p[1]]
52 |         e1,e2 = doc.GetElement(eid1),doc.GetElement(eid2)
53 |         joined = JoinGeometryUtils.AreElementsJoined(doc,e1,e2)
54 |         if joined:
55 |             joined_pairs.append((e1,e2))
56 | 
57 | if len(joined_pairs) > 0:
58 |     t = Transaction(doc)
59 |     t.Start(__title__)
60 |     for p in joined_pairs:
61 |         JoinGeometryUtils.UnjoinGeometry(doc,p[0],p[1])
62 |         c+=1
63 |     t.Commit()
64 | 
65 | TaskDialog.Show(__title__,"%d pairs of elements unjoined" % c)
66 | 


--------------------------------------------------------------------------------
/pyApex.tab/Selection.panel/sel1.stack/ZoomBasePoint.pushbutton/script.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | __title__ = 'Zoom Base Point'
 3 | __doc__ = """Zoom in active view to Project base point. If it's hidden - enables "Reveal Hidden" mode.
 4 | Shift+Click - to Site point
 5 | 
 6 | Находит базовую точку проекта на текущем виде. Если точка скрыта - включает режим показа скрытых объектов.
 7 | Shift+Click - Точку съемки"""
 8 | 
 9 | __helpurl__ = "https://apex-project.github.io/pyApex/help#zoom-base-point"
10 | 
11 | try:
12 |     from pyrevit.versionmgr import PYREVIT_VERSION
13 | except:
14 |     from pyrevit import versionmgr
15 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
16 | 
17 | pyRevitNewer44 = PYREVIT_VERSION.major >=4 and PYREVIT_VERSION.minor >=5
18 | 
19 | if pyRevitNewer44:
20 |     from pyrevit import script, revit
21 |     output = script.get_output()
22 |     logger = script.get_logger()
23 |     linkify = output.linkify
24 |     doc = revit.doc
25 |     uidoc = revit.uidoc
26 |     selection = revit.get_selection()
27 | else:
28 |     from scriptutils import logger, this_script
29 |     from revitutils import doc, selection, uidoc
30 | 
31 |     output = this_script.output
32 | 
33 | from Autodesk.Revit.DB import FilteredElementCollector, BuiltInCategory, ElementId, Transaction
34 | 
35 | cl = FilteredElementCollector(doc, uidoc.ActiveView.Id).WhereElementIsNotElementType()
36 | 
37 | if __shiftclick__:
38 |     category = BuiltInCategory.OST_SharedBasePoint
39 | else:
40 |     category = BuiltInCategory.OST_ProjectBasePoint
41 | 
42 | elements = cl.OfCategory(category).ToElementIds()
43 | 
44 | if len(elements)==0:
45 |     t = Transaction(doc, "[%s] Reveal hidden" % __title__)
46 |     t.Start()
47 |     try:
48 |         uidoc.ActiveView.EnableRevealHiddenMode()
49 |         cl = FilteredElementCollector(doc, uidoc.ActiveView.Id).WhereElementIsNotElementType()
50 |         elements = cl.OfCategory(category).ToElementIds()
51 |     except:
52 |         elements = []
53 | 
54 |     if len(elements) == 0:
55 |         t.RollBack()
56 |         cl = FilteredElementCollector(doc).WhereElementIsNotElementType()
57 |         elements = cl.OfCategory(category).ToElementIds()
58 |     else:
59 |         t.Commit()
60 | 
61 | uidoc.ShowElements(elements[0])


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils2.stack/SumParameter.pushbutton/window.xaml:
--------------------------------------------------------------------------------
 1 | <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 2 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 3 |         Title="Sum parameter values:" Height="300" Width="400" ShowInTaskbar="False" ResizeMode="NoResize"
 4 |         WindowStartupLocation="CenterScreen" ScrollViewer.VerticalScrollBarVisibility="Disabled" HorizontalContentAlignment="Center">
 5 |     <Grid Margin="20">
 6 |         <Grid.RowDefinitions>
 7 |             <RowDefinition Height="50"/>
 8 |             <RowDefinition Height="50"/>
 9 |             <RowDefinition Height="60"/>
10 |             <RowDefinition Height="20"/>
11 |             <RowDefinition Height="*"/>
12 |             <RowDefinition Height="auto" MinHeight="20"/>
13 |         </Grid.RowDefinitions>
14 |         <StackPanel Grid.Row="0" Margin="0,0,0,0">
15 |             <Label x:Name="label01" Content="Get value from:" HorizontalAlignment="Left" VerticalAlignment="Top"/>
16 |             <ComboBox x:Name="parameterToGet" HorizontalAlignment="Stretch" VerticalAlignment="Top" IsEditable="True"
17 |                       StaysOpenOnEdit="True"/>
18 |         </StackPanel>
19 | 
20 |         <StackPanel Grid.Row="1" Margin="0,0,0,0">
21 |             <Label x:Name="label03" Content="Operation" HorizontalAlignment="Left" VerticalAlignment="Top"/>
22 |             <ComboBox x:Name="operation" Width="200" HorizontalAlignment="Left" VerticalAlignment="Top" IsEditable="True"
23 |                       StaysOpenOnEdit="True"/>
24 |         </StackPanel>
25 |         <StackPanel Grid.Row="2" Margin="0,0,0,0">
26 |             <Label x:Name="label02" Content="... parameter to update:" HorizontalAlignment="Left" VerticalAlignment="Top"/>
27 |             <ComboBox x:Name="parameterToSet" HorizontalAlignment="Stretch" VerticalAlignment="Top" IsEditable="True"
28 |                       StaysOpenOnEdit="True"/>
29 |         </StackPanel>
30 |         <StackPanel Grid.Row="3" Margin="0,0,0,0">
31 |             <CheckBox x:Name="resetToZero" Content="Reset first parameter to '0'"/>
32 |         </StackPanel>
33 | 
34 |         <Button Grid.Row="5" Grid.ColumnSpan="5" Margin="0,15,0,0" Click="run" Content="Sum value" />
35 |     </Grid>
36 | </Window>
37 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/Purge.pulldown/PurgeFamilies.pushbutton/config.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | try:
 3 |     from pyrevit.versionmgr import PYREVIT_VERSION
 4 | except:
 5 |     from pyrevit import versionmgr
 6 | 
 7 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
 8 | 
 9 | pyRevitNewer44 = (PYREVIT_VERSION.major, PYREVIT_VERSION.minor) >= (4, 5)
10 | 
11 | if pyRevitNewer44:
12 |     from pyrevit import script
13 |     from pyrevit.forms import WPFWindow, alert, pick_folder
14 | 
15 |     my_config = script.get_config()
16 | else:
17 |     from scriptutils import this_script as script
18 |     from scriptutils.userinput import WPFWindow, pick_folder
19 |     my_config = script.config
20 | 
21 |     from Autodesk.Revit.UI import TaskDialog
22 |     def alert(msg):
23 |         TaskDialog.Show('pyrevit', msg)
24 | 
25 | import purge_families_defaults as cdef
26 | import pyapex_utils as pau
27 | import os
28 | 
29 | class PurgeFamiliesConfigWindow(WPFWindow):
30 |     def __init__(self, xaml_file_name):
31 | 
32 |         WPFWindow.__init__(self, xaml_file_name)
33 |         try:
34 |             self.temp_dir.Text = pau.list2str(my_config.temp_dir)
35 |         except:
36 |             self.restore_defaults(None,None,"temp_dir")
37 | 
38 |     def restore_defaults(self, p1=None, p2=None, *args):
39 |         if len(args) == 0 or "temp_dir" in args:
40 |             self.temp_dir.Text = pau.list2str(cdef.temp_dir)
41 | 
42 |     # noinspection PyUnusedLocal
43 |     # noinspection PyMethodMayBeStatic
44 |     def save_options(self, sender, args):
45 |         errors = []
46 |         directory = self.temp_dir.Text
47 |         try:
48 |             if not os.path.exists(directory):
49 |                 os.makedirs(directory)
50 | 
51 |             if not os.path.isdir(directory):
52 |                 errors.append("Specified path is not a directory")
53 |             if len(errors) == 0:
54 |                 my_config.temp_dir = pau.str2list(self.temp_dir.Text)
55 |         except Exception as e:
56 |             errors.append("Specified path is invalid.\n%s" % str(e))
57 | 
58 |         if errors:
59 |             alert("Can't save config.\n" + "\n".join(errors))
60 |             return
61 |         else:
62 |             script.save_config()
63 |             self.Close()
64 | 
65 |     def pick(self, sender, args):
66 |         path = pick_folder()
67 |         if path:
68 |             self.temp_dir.Text = path
69 | 
70 | 
71 | if __name__ == '__main__':
72 |     PurgeFamiliesConfigWindow('PurgeFamiliesConfig.xaml').ShowDialog()
73 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/ShowDependent.pushbutton/config.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | try:
 3 |     from pyrevit.versionmgr import PYREVIT_VERSION
 4 | except:
 5 |     from pyrevit import versionmgr
 6 | 
 7 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
 8 | 
 9 | pyRevitNewer44 = PYREVIT_VERSION.major >= 4 and PYREVIT_VERSION.minor >= 5
10 | 
11 | if pyRevitNewer44:
12 |     from pyrevit import script
13 |     from pyrevit.forms import WPFWindow, alert
14 | 
15 |     my_config = script.get_config()
16 | else:
17 |     from scriptutils import this_script as script
18 |     from scriptutils.userinput import WPFWindow, pick_folder
19 |     my_config = script.config
20 | 
21 |     from Autodesk.Revit.UI import TaskDialog
22 |     def alert(msg):
23 |         TaskDialog.Show('pyrevit', msg)
24 | 
25 | import show_dependent_defaults as cdef
26 | import pyapex_utils as pau
27 | 
28 | class ShowDependentConfigWindow(WPFWindow):
29 |     def __init__(self, xaml_file_name):
30 | 
31 |         WPFWindow.__init__(self, xaml_file_name)
32 |         try:
33 |             self.limit.Text = str(my_config.limit)
34 |         except:
35 |             self.restore_defaults(None,None,"limit")
36 | 
37 |         try:
38 |             self.exceptions.Text = pau.list2str(my_config.exceptions)
39 |         except:
40 |             self.restore_defaults(None,None,"exceptions")
41 | 
42 | 
43 |     def restore_defaults(self, p1=None, p2=None, *args):
44 |         if len(args) == 0 or "limit" in args:
45 |             self.limit.Text = str(cdef.limit)
46 | 
47 |         if len(args) == 0 or "exceptions" in args:
48 |             self.exceptions.Text = pau.list2str(cdef.exceptions)
49 | 
50 |     # noinspection PyUnusedLocal
51 |     # noinspection PyMethodMayBeStatic
52 |     def save_options(self, sender, args):
53 |         errors = []
54 |         try:
55 |             my_config.exceptions = pau.str2list(self.exceptions.Text)
56 |         except:
57 |             errors.append("Exceptions value is invalid")
58 | 
59 |         try:
60 |             v = int(self.limit.Text)
61 |             assert v >= 0
62 |             my_config.limit = v
63 |         except:
64 |             errors.append("Limit value should be either zero or a positive integer")
65 | 
66 |         if errors:
67 |             alert("Can't save config.\n" + "\n".join(errors))
68 |             return
69 |         else:
70 |             script.save_config()
71 |             self.Close()
72 | 
73 |     def NumberValidationTextBox(self, sender, e):
74 |         try:
75 |             x = int(e.Text.strip())
76 |             e.Handled = False
77 |         except:
78 |             e.Handled = True
79 | 
80 | 
81 | if __name__ == '__main__':
82 |     ShowDependentConfigWindow('ShowDependentConfig.xaml').ShowDialog()
83 | 


--------------------------------------------------------------------------------
/pyApex.tab/WIP.panel/CopyParameterTest.pushbutton/script.py:
--------------------------------------------------------------------------------
 1 | __beta__ = True
 2 | from pyrevit import revit, DB
 3 | import pyapex_parameters as pyap
 4 | element_id_int = 2442
 5 | 
 6 | 
 7 | 
 8 | def collect_parameters(element, prefix=""):
 9 |     result = set()
10 |     prefix = prefix.lower()
11 |     for p in element.Parameters:
12 |         p_def = p.Definition
13 | 
14 |         if p_def.Name.lower().startswith(prefix):
15 |             result.add(p_def)
16 |     return result
17 | 
18 | test_values = [
19 |     "Input1_Double -> Output2_Length",
20 |     "Input5_String_Float -> Output2_Length",
21 |     "Input2_Length -> Output4_String",
22 |     "Input7_ElementId -> Output3_Integer"
23 | ]
24 | test_values =[]
25 | def main():
26 |     print("run")
27 |     element = revit.doc.GetElement(DB.ElementId(element_id_int))
28 |     input_parameters = collect_parameters(element, "input")
29 |     output_parameters = collect_parameters(element, "output")
30 |     input_parameters = sorted(input_parameters, key=lambda d: d.Name)
31 |     output_parameters = sorted(output_parameters, key=lambda d: d.Name)
32 | 
33 |     with revit.TransactionGroup():
34 |         # clean parameters
35 |         if __shiftclick__:
36 |             with revit.Transaction():
37 |                 for op_def in output_parameters:
38 |                     pyap.erase_parameter(element,op_def)
39 |         # fill parameters
40 |         else:
41 |             for op_def in output_parameters:
42 |                 for ip_def in input_parameters:
43 |                     title = "%s -> %s"  % (ip_def.Name, op_def.Name)
44 |                     if test_values and title not in test_values:
45 |                         continue
46 |                     print(title)
47 |                     param_get = element.get_Parameter(ip_def)
48 |                     param_set = element.get_Parameter(op_def)
49 |                     p_get = pyap.parameter_value_get(param_get)
50 | 
51 |                     if (param_get.StorageType == DB.StorageType.String):
52 |                         p_get_v = param_get.AsString()
53 |                     else:
54 |                         p_get_v = param_get.AsValueString()
55 | 
56 |                     with revit.Transaction():
57 |                         try:
58 |                             result = pyap.copy_parameter(element, ip_def, op_def)
59 |                             print("result: %s" % str(result))
60 |                         except Exception as exc:
61 |                             print("Exception %s" % exc)
62 |                     if (param_set.StorageType == DB.StorageType.String):
63 |                         p_set_v = param_set.AsString()
64 |                     else:
65 |                         p_set_v = param_set.AsValueString()
66 |                     print("%s -> %s" % (p_get_v, p_set_v))
67 |                     print("\n")
68 | 
69 | if __name__ == '__main__':
70 |     main()


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils.stack/WhiteMaterials.pushbutton/config.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | try:
 3 |     from pyrevit.versionmgr import PYREVIT_VERSION
 4 | except:
 5 |     from pyrevit import versionmgr
 6 | 
 7 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
 8 | 
 9 | pyRevitNewer44 = PYREVIT_VERSION.major >= 4 and PYREVIT_VERSION.minor >= 5
10 | 
11 | if pyRevitNewer44:
12 |     from pyrevit import script
13 |     from pyrevit.forms import WPFWindow, alert
14 |     logger = script.get_logger()
15 |     my_config = script.get_config()
16 | else:
17 |     from scriptutils import this_script as script
18 |     from scriptutils import logger
19 |     from scriptutils.userinput import WPFWindow, pick_folder
20 |     my_config = script.config
21 | 
22 |     from Autodesk.Revit.UI import TaskDialog
23 |     def alert(msg):
24 |         TaskDialog.Show('pyrevit', msg)
25 | 
26 | import white_materials_defaults as cdef
27 | import pyapex_utils as pau
28 | 
29 | class WhiteMaterialsConfigWindow(WPFWindow):
30 |     def __init__(self, xaml_file_name):
31 | 
32 |         WPFWindow.__init__(self, xaml_file_name)
33 |         try:
34 |             self.exceptions.Text = pau.list2str(my_config.exceptions)
35 |         except:
36 |             self.restore_defaults(None,None,"exceptions")
37 | 
38 |         try:
39 |             self.material.Text = pau.list2str(my_config.material)
40 |         except:
41 |             self.restore_defaults(None,None,"material")
42 | 
43 |         try:
44 |             self.ignore_transparent.IsChecked = bool(my_config.ignore_transparent)
45 |         except:
46 |             self.restore_defaults(None,None,"ignore_transparent")
47 | 
48 |     def restore_defaults(self, p1=None, p2=None, *args):
49 |         if len(args) == 0 or "exceptions" in args:
50 |             self.exceptions.Text = pau.list2str(cdef.exceptions)
51 |         if len(args) == 0 or "material" in args:
52 |             self.material.Text = pau.list2str(cdef.material)
53 |         if len(args) == 0 or "ignore_transparent" in args:
54 |             self.ignore_transparent.IsChecked = bool(cdef.ignore_transparent)
55 | 
56 |     # noinspection PyUnusedLocal
57 |     # noinspection PyMethodMayBeStatic
58 |     def save_options(self, sender, args):
59 |         errors = []
60 |         try:
61 |             my_config.exceptions = pau.str2list(self.exceptions.Text.encode('utf-8'))
62 |         except:
63 |             errors.append("Exceptions value is invalid")
64 | 
65 |         try:
66 |             v = self.material.Text
67 |             assert len(v) >= 0
68 | 
69 |             my_config.material = v.encode('utf-8')
70 |         except Exception as exc:
71 |             errors.append("Material name is invalid")
72 |             logger.debug(exc)
73 | 
74 |         try:
75 |             my_config.ignore_transparent = bool(self.ignore_transparent.IsChecked)
76 |         except:
77 |             errors.append("Ignore transparent value is invalid")
78 | 
79 |         if errors:
80 |             alert("Can't save config.\n" + "\n".join(errors))
81 |             return
82 |         else:
83 |             script.save_config()
84 |             self.Close()
85 | 
86 | 
87 | if __name__ == '__main__':
88 |     WhiteMaterialsConfigWindow('WhiteMaterialsConfig.xaml').ShowDialog()
89 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils.stack/SortAndEnumerate.pushbutton/window.xaml:
--------------------------------------------------------------------------------
 1 | <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 2 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 3 |         Title="Enumerate objects or views:" Height="350" Width="400" ShowInTaskbar="False" ResizeMode="NoResize"
 4 |         WindowStartupLocation="CenterScreen" ScrollViewer.VerticalScrollBarVisibility="Disabled" HorizontalContentAlignment="Center">
 5 |     <Grid Margin="20">
 6 |         <Grid.RowDefinitions>
 7 |             <RowDefinition Height="50"/>
 8 |             <RowDefinition Height="60"/>
 9 |             <RowDefinition Height="50"/>
10 |             <RowDefinition Height="50"/>
11 |             <RowDefinition Height="*"/>
12 |             <RowDefinition Height="auto" MinHeight="20"/>
13 |         </Grid.RowDefinitions>
14 |         <Grid.ColumnDefinitions>
15 |             <ColumnDefinition Width="1*"/>
16 |             <ColumnDefinition Width="0.05*"/>
17 |             <ColumnDefinition Width="1*"/>
18 |             <ColumnDefinition Width="0.05*"/>
19 |             <ColumnDefinition Width="1*"/>
20 |         </Grid.ColumnDefinitions>
21 | 
22 |         <StackPanel Grid.Row="0" Grid.ColumnSpan="5" Margin="0,0,0,0">
23 |             <Label x:Name="label01" Content="Sort by:" HorizontalAlignment="Left" VerticalAlignment="Top"/>
24 |             <ComboBox x:Name="parameterToSort" HorizontalAlignment="Stretch" VerticalAlignment="Top" IsEditable="True"
25 |                       StaysOpenOnEdit="True"/>
26 |         </StackPanel>
27 | 
28 |         <StackPanel Grid.Row="1" Grid.ColumnSpan="5" Margin="0,0,0,0">
29 |             <Label x:Name="label02" Content="Parameter to change:" HorizontalAlignment="Left" VerticalAlignment="Top"/>
30 |             <ComboBox x:Name="parameterToSet" HorizontalAlignment="Stretch" VerticalAlignment="Top" IsEditable="True"
31 |                       StaysOpenOnEdit="True"/>
32 |         </StackPanel>
33 |         <StackPanel Grid.Column="0" Grid.Row="2" Grid.ColumnSpan="3">
34 |             <Label x:Name="label1" Content="Format (use %s as placer, e.g. 'List # %s'):" HorizontalAlignment="Left" VerticalAlignment="Top"/>
35 |             <TextBox x:Name="textFormat" HorizontalAlignment="Stretch" Height="23" TextWrapping="Wrap" Text="%s" VerticalAlignment="Top" />
36 |         </StackPanel>
37 |         <StackPanel Grid.Column="0" Grid.Row="3" >
38 |             <Label x:Name="label2" Content="Start from:" HorizontalAlignment="Left" VerticalAlignment="Top"/>
39 |             <TextBox x:Name="startFrom" HorizontalAlignment="Left" Height="23" Width="40" Text="0" VerticalAlignment="Top"
40 |             PreviewTextInput="NumberValidationTextBox"/>
41 |         </StackPanel>
42 |         <StackPanel Grid.Column="2" Grid.Row="3">
43 |             <Label x:Name="label3" Content="Leading zeros:" HorizontalAlignment="Left" VerticalAlignment="Top"/>
44 |             <TextBox x:Name="leadingZeros" HorizontalAlignment="Left" Height="23" Width="40" Text="0" VerticalAlignment="Top"
45 |             PreviewTextInput="NumberValidationTextBox"/>
46 |         </StackPanel>
47 |         <StackPanel Grid.Column="4" Grid.Row="3">
48 |             <Label x:Name="label4" Content=" " HorizontalAlignment="Left" VerticalAlignment="Top"/>
49 |             <CheckBox x:Name="isReversed" Content="Reverse"/>
50 |         </StackPanel>
51 | 
52 |         <Button Grid.Row="5" Grid.ColumnSpan="5" Margin="0,15,0,0" Click="run" Content="Enumerate" />
53 |     </Grid>
54 | </Window>
55 | 


--------------------------------------------------------------------------------
/pyApex.tab/Detail.panel/FlipGridEnds.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __title__ = 'Flip\nGrid Ends'
  3 | __doc__ = """Flip visibility of bubbles at the ends of selected grids. If both bubbles were visible ony one lefts.
  4 | 
  5 | Переключает отображения кружочков для выделенных осей. Если у оси были видимы оба кружочка, будет отображаться только один"""
  6 | 
  7 | __helpurl__ = "https://apex-project.github.io/pyApex/help#flip-grid-ends"
  8 | 
  9 | try:
 10 |     from pyrevit.versionmgr import PYREVIT_VERSION
 11 | except:
 12 |     from pyrevit import versionmgr
 13 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
 14 | 
 15 | pyRevitNewer44 = PYREVIT_VERSION.major >=4 and PYREVIT_VERSION.minor >=5
 16 | 
 17 | if pyRevitNewer44:
 18 |     from pyrevit import script, revit
 19 |     output = script.get_output()
 20 |     logger = script.get_logger()
 21 |     linkify = output.linkify
 22 |     doc = revit.doc
 23 |     uidoc = revit.uidoc
 24 |     selection = revit.get_selection()
 25 | else:
 26 |     from scriptutils import logger, this_script
 27 |     from revitutils import doc, selection, uidoc
 28 | 
 29 |     output = this_script.output
 30 | 
 31 | 
 32 | from Autodesk.Revit.DB import Grid, DatumEnds, Transaction
 33 | from Autodesk.Revit import UI
 34 | from Autodesk.Revit.UI import TaskDialog
 35 | 
 36 | class PickByCategorySelectionFilter(UI.Selection.ISelectionFilter):
 37 |     def __init__(self, catname):
 38 |         self.category = catname
 39 | 
 40 |     # standard API override function
 41 |     def AllowElement(self, element):
 42 |         if self.category in element.Category.Name:
 43 |             return True
 44 |         else:
 45 |             return False
 46 | 
 47 |     # standard API override function
 48 |     def AllowReference(self, refer, point):
 49 |         return False
 50 | 
 51 | 
 52 | def pickbycategory(catname):
 53 |     msfilter = PickByCategorySelectionFilter(catname)
 54 |     selection_list = revit.pick_rectangle(pick_filter=msfilter)
 55 |     return selection_list
 56 | 
 57 | 
 58 | def get_selected_grids():
 59 |     sel = selection.elements
 60 |     sel = filter(lambda x: type(x) == Grid, sel)
 61 | 
 62 |     if len(sel) == 0:
 63 |         TaskDialog.Show(__title__, "Select Grids to flip bubbles visibility")
 64 |         sel = pickbycategory("Grid")
 65 |         if not sel:
 66 |             return
 67 | 
 68 |     return list(sel)
 69 | 
 70 | 
 71 | def flip_grid(grid, view):
 72 |     if not grid.CanBeVisibleInView(view):
 73 |         return
 74 | 
 75 |     ends = [
 76 |         DatumEnds.End0,
 77 |         DatumEnds.End1
 78 |     ]
 79 |     last = None
 80 |     changed = 0
 81 |     for end in ends:
 82 |         if grid.IsBubbleVisibleInView(end, view) and not last:
 83 |             grid.HideBubbleInView(end, view)
 84 |             last = True
 85 |             changed += 1
 86 |         else:
 87 |             if not grid.IsBubbleVisibleInView(end, view):
 88 |                 grid.ShowBubbleInView(end, view)
 89 |                 changed += 1
 90 | 
 91 |     return bool(changed)
 92 | 
 93 | 
 94 | def main():
 95 |     sel_grids = get_selected_grids()
 96 |     if not sel_grids:
 97 |         return
 98 |     active_view = doc.ActiveView
 99 | 
100 |     changed = 0
101 |     t = Transaction(doc)
102 |     t.Start(__title__)
103 | 
104 |     for g in sel_grids:
105 |         changed += bool( flip_grid(g, active_view) )
106 | 
107 |     if changed > 0:
108 |         t.Commit()
109 |     else:
110 |         t.Rollback()
111 | 
112 |     if changed != len(sel_grids):
113 |         TaskDialog.Show(__title__, "%d of %d grids were flipped" % (changed, len(sel_grids)))
114 |     elif changed == 0:
115 |         TaskDialog.Show(__title__, "Nothing flipped")
116 | 
117 | if __name__ == '__main__':
118 |     main()


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # THIS PROJECT IS NOT MAINTAINED
 2 | 
 3 | Unfortunately I do not have enough time to add new scripts to pyapex extension.
 4 | Sorry that I am not always able to address new issues promptly.
 5 | 
 6 | Though I will still try to find time to merge pull request. Therefore, pull requests are welcome and in a priority for me. So if you really need a script to 
 7 | be fixed, do not hesitate to try it on your own and make a PR or at least send a fix as a .py file using issues or per email at alex@hiteca.ru
 8 | 
 9 | 
10 | ---
11 | 
12 | # Extension for pyRevit 
13 | 
14 | An extension for [pyRevit](http://eirannejad.github.io/pyRevit/)
15 | 
16 | https://apex-project.github.io/pyApex
17 | 
18 | ## Updates:
19 | 
20 | **2019-08-14** UPD: Copy Parameter script fixed for Revit 2022 and 2023
21 | 
22 | **2019-08-14** New features: Sum/substract parameters; Save selected families
23 | 
24 | **2019-05-07** New feature: Exclude grouped elements from selection
25 | 
26 | **2019-04-17** New feature: link many DWG, RVT or IFC at once (Link more). Beta
27 | 
28 | **2019-02-21** New feature: Remove and recover constraints
29 | 
30 | **2019-02-06** New features: Copy between docs, Sort elements along curve (Sort and Enumerate script)
31 | 
32 | ## Features
33 | 
34 | ![pyApex](https://raw.githubusercontent.com/apex-project/pyApex/gh-pages/assets/img/pyApex_buttons.png)
35 | 
36 | [All available features...](https://apex-project.github.io/pyApex/help)
37 | 
38 | ---
39 | 
40 | # Install guide / Инструкция по установке
41 | 
42 | ###### EN
43 | 
44 | pyApex is an extension (or series of scripts) for Revit addin named [pyRevit](http://eirannejad.github.io/pyRevit/). So before using our scripts you should install pyRevit. Then just enable our extension in settings.
45 | 
46 | 1. Download and install pyRevit from [http://eirannejad.github.io/pyRevit/](http://eirannejad.github.io/pyRevit/)
47 | 
48 | 2. Open Revit. Then install extension from pyRevit tab - Extensions - select pyApex and click Install Package. Voila!
49 | 
50 | > If there is not pyApex in extensions list or if you stucked with another problem during install go to [Troubleshoting](https://apex-project.github.io/pyApex/#troubleshooting)
51 | 
52 | ###### RU
53 | 
54 | pyApex - это набор скриптов для Revit-плагина, который называется [pyRevit](http://eirannejad.github.io/pyRevit/). Поэтому для использования наших скриптов вам необходимо установить pyRevit, а затем в его настройках включить расширение pyApex
55 | 
56 | 1. Скачайте и установите pyRevit [http://eirannejad.github.io/pyRevit/](http://eirannejad.github.io/pyRevit/) (на время установки необходимо подключение к интернету)
57 | 
58 | 2. Запустите Revit, на вкладке pyRevit - в подгруппе pyRevit нажмите кнопку Extenstions. В открывшемся списке выберите в списке pyApex и нажмите Install Package. Готово!
59 | 
60 | > Если в списке расширений нет pyApex, или в процессе установки возникли проблемы, обратитесь к разделу [Устранение неполадок](https://apex-project.github.io/pyApex/#устранение-неполадок)
61 | 
62 | 
63 | ![Extensions button](https://raw.githubusercontent.com/apex-project/pyApex/gh-pages/assets/img/pyrevit_extensions_button.png)
64 | 
65 | ![Extensions window](https://raw.githubusercontent.com/apex-project/pyApex/gh-pages/assets/img/pyrevit_extensions_window.png)
66 | 
67 | ---
68 | 
69 | ## Contribution
70 | 
71 | Feel free to report about bugs to issues tab. 
72 | 
73 | You're also welcome to make any contributions - add comments, fork and make pull-requests. With any ideas write to aleksey.melnikov@apex-project.ru
74 | 
75 | 
76 | ## About
77 | 
78 | Coded by Aleksey Melnikov at Apex Project bureau, Moscow
79 | 
80 | These scripts are avariable and easy to use thanks to pyRevit project by Ehsan Iran-Nejad
81 | 
82 | License: This package is licensed under GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007.
83 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils3.stack/CopyBtwDocs.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __title__ = 'Copy btw. Docs'
  3 | __doc__ = """Copy selection from active document to another opened document.
  4 | In case of geometry it uses origin-to-origin alignment
  5 | Context: elements should be selected
  6 | 
  7 | Копирует выбранные элементы из активного документа в другой открытй документ
  8 | При копировании геометрии используется выравнивание по нулю проекта
  9 | Контекст: необходимо выбрать элементы для копирования"""
 10 | __context__ = 'Selection'
 11 | 
 12 | from pyrevit import script, revit, forms
 13 | from Autodesk.Revit.DB import Transaction, Transform, ElementId, ElementTransformUtils, FilteredElementCollector, BuiltInCategory
 14 | from Autodesk.Revit.DB.Architecture import *
 15 | import clr
 16 | clr.AddReference("System")
 17 | from System.Collections.Generic import List
 18 | 
 19 | logger = script.get_logger()
 20 | 
 21 | def run(sel, location_option):
 22 |     logger.info("Location option: %s " % location_option)
 23 |     docs = __revit__.Application.Documents
 24 |     # where to copy
 25 |     src_doc = __revit__.ActiveUIDocument.Document
 26 |     docs = filter(lambda d: not d.IsLinked and d != src_doc, docs)
 27 |     trg_docs = forms.SelectFromList.show(docs, name_attr='Title', title='Documents to paste selection',
 28 |                                           button_name='Paste', multiselect=True)
 29 |     null_point_src = None
 30 |     null_point_cat = None
 31 |     if location_option == "Project Base Point":
 32 |         null_point_cat = BuiltInCategory.OST_SharedBasePoint
 33 |     elif location_option == "Shared Site Point":
 34 |         null_point_cat = BuiltInCategory.OST_ProjectBasePoint
 35 | 
 36 |     if null_point_cat:
 37 |         null_point_src = FilteredElementCollector(src_doc).WhereElementIsNotElementType().OfCategory(null_point_cat).WhereElementIsNotElementType().ToElements()
 38 |         if len(null_point_src) == 0:
 39 |             logger.warning("Point for location option wasn't found in source document. Default alignment will be used")
 40 | 
 41 |     for trg_doc in trg_docs:
 42 |         logger.debug(trg_doc)
 43 |         logger.debug(len(trg_doc.Title))
 44 |         s = "Copy %d elements from %s to %s" % (len(sel), src_doc.Title, trg_doc.Title)
 45 |         print(s)
 46 |         # logger.info(s) # TODO Fix - cannot log cyrylic project name
 47 | 
 48 |         # Transform
 49 |         transform_vector = None
 50 |         if null_point_src:
 51 |             null_point_trg = FilteredElementCollector(trg_doc).WhereElementIsNotElementType().OfCategory(
 52 |                 null_point_cat).WhereElementIsNotElementType().ToElements()
 53 |             if len(null_point_trg) == 0:
 54 |                 logger.warning(
 55 |                     "Point for location option wasn't found in target document. Document will be skipped")
 56 |                 continue
 57 |             # _transform_vector = null_point_trg[0].GetTransform().BasisX - null_point_src[0].GetTransform().BasisX
 58 |             print(null_point_trg[0].BoundingBox[null_point_trg[0]])
 59 |             transform_vector = Transform.CreateTranslation(null_point_trg[0].BoundingBox.Min - null_point_src[0].BoundingBox.Min)
 60 | 
 61 |         t = Transaction(trg_doc, __title__ + " - %d elements from %s" % (len(sel), src_doc.Title))
 62 |         t.Start()
 63 |         try:
 64 |             ElementTransformUtils.CopyElements(src_doc, List[ElementId](sel), trg_doc, transform_vector, None)
 65 |             t.Commit()
 66 |         except Exception as exc:
 67 |             t.RollBack()
 68 |             logger.error(exc)
 69 | 
 70 | def have_location(elements):
 71 |     for e in elements:
 72 |         if getattr(e, "Location"):
 73 |             return True
 74 |     return False
 75 | 
 76 | def get_locaton_option():
 77 |     options = [
 78 |         "Document null",
 79 |         "Project Base Point",
 80 |         "Shared Site Point"
 81 |     ]
 82 |     return forms.SelectFromList.show(options, title='Select alignment type', button_name='Continue')
 83 | 
 84 | if __name__ == '__main__':
 85 |     sel_elements = revit.get_selection().elements
 86 |     location_option = None
 87 | 
 88 |     # TODO select location type
 89 |     # TODO align by view (if not exist?)
 90 |     # if have_location(sel_elements):
 91 |     #     location_option = get_locaton_option()
 92 |     #     if not location_option:
 93 |     #         forms.alert("Nothing selected. Default align will be used")
 94 | 
 95 |     sel = revit.get_selection().element_ids
 96 |     if not sel:
 97 |         forms.alert("Nothing selected")
 98 |     else:
 99 |         run(sel, location_option)
100 | 


--------------------------------------------------------------------------------
/pyApex.tab/Model.panel/DisableConstraints.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __title__ = 'Disable\nConstraints'
  3 | 
  4 | __doc__ = """Disable all Constraints in the project (all locked dimensions). 
  5 | Shift+Click - recover from previous run"""
  6 | 
  7 | __helpurl__ = "https://apex-project.github.io/pyApex/help#disable-constraints"
  8 | 
  9 | from Autodesk.Revit.DB import BuiltInCategory, ElementId, JoinGeometryUtils, Transaction, FilteredElementCollector
 10 | from Autodesk.Revit.UI import TaskDialog, TaskDialogCommonButtons, TaskDialogResult,TaskDialogCommandLinkId
 11 | from pyrevit import script
 12 | from pyrevit.revit import doc, selection
 13 | import pickle
 14 | import os
 15 | 
 16 | selection = selection.get_selection()
 17 | append_mode = True
 18 | 
 19 | def get_datafile(reverse):
 20 |     global append_mode
 21 |     datafile = script.get_document_data_file("pyApex_Constraints", "pym")
 22 |     saved_list = []
 23 | 
 24 |     if os.path.exists(datafile):
 25 |         if reverse == False:
 26 |             td = TaskDialog("Constraints")
 27 |             td.MainInstruction = "File with elements saved after previous run found.\nHow to deal with it?"
 28 |             td.AddCommandLink(TaskDialogCommandLinkId.CommandLink1, "Remove it and replace")
 29 |             td.AddCommandLink(TaskDialogCommandLinkId.CommandLink2, "Append new data")
 30 |             td.AllowCancellation = True
 31 |             taskDialogResult = td.Show()
 32 |             if taskDialogResult == TaskDialogResult.Cancel:
 33 |                 return None, None
 34 |             elif taskDialogResult == TaskDialogResult.CommandLink1:
 35 |                 append_mode = False
 36 |             else:
 37 |                 append_mode = True
 38 | 
 39 |         if append_mode:
 40 |             f = open(datafile, 'r')
 41 |             saved_list = pickle.load(f)
 42 |             f.close()
 43 | 
 44 |     # remove duplicates
 45 |     ids = list(set(saved_list))
 46 |     return datafile, ids
 47 | 
 48 | 
 49 | def save(datafile, ids):
 50 |     # remove duplicates
 51 |     ids = list(set(ids))
 52 |     # write
 53 |     f = open(datafile, 'w')
 54 |     pickle.dump(ids, f)
 55 |     f.close()
 56 | 
 57 | 
 58 | def IsGrouped(element):
 59 |     return element.GroupId.IntegerValue != -1
 60 | 
 61 | 
 62 | def process(datafile, saved_list=[], reverse=False):
 63 | 
 64 |     if not reverse:
 65 |         cl = FilteredElementCollector(doc).WhereElementIsNotElementType().OfCategory(BuiltInCategory.OST_Constraints)
 66 |         constraints = cl.ToElements()
 67 |         constraints_to_change = filter(lambda c: c.NumberOfSegments == 0, constraints)
 68 |         constraints_to_change = list(filter(lambda c: c.IsLocked, constraints_to_change))
 69 | 
 70 |         constraints_grouped = list(filter(lambda c: IsGrouped(c), constraints_to_change))
 71 |         constraints_to_change = list(filter(lambda c: not IsGrouped(c), constraints_to_change))
 72 |         
 73 |         td_text = "%d enabled Constraints found. Disable them?" % len(constraints_to_change)
 74 | 
 75 |         if (len(constraints_grouped) > 0):
 76 |             td_text += ("\n(%d Constraints are in groups, they will not be affected)" % len(constraints_grouped))
 77 |     else:
 78 | 
 79 |         td_text = "Reverse mode.\n%d saved Constraints found. Recover them?" % len(saved_list)
 80 |         constraints_to_change = []
 81 |         for id_int in saved_list:
 82 |             try:
 83 |                 element = doc.GetElement(ElementId(id_int))
 84 |                 constraints_to_change.append(element)
 85 |             except:
 86 |                 pass
 87 | 
 88 |     tdres = TaskDialog.Show("Constraints", td_text,
 89 |                             TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No)
 90 | 
 91 |     if tdres == TaskDialogResult.No:
 92 |         return
 93 | 
 94 |     t = Transaction(doc, __title__)
 95 |     t.Start()
 96 |     is_error = False
 97 |     try:
 98 |         for constraint in constraints_to_change:
 99 |             if not constraint:
100 |                 continue
101 |             constraint.IsLocked = True if reverse else False
102 |             if not reverse:
103 |                 saved_list.append(constraint.Id.IntegerValue)
104 | 
105 |     except Exception as exc:
106 |         is_error = True
107 |         t.RollBack()
108 |         TaskDialog.Show(__title__, "Error. Changes cancelled.")
109 |     else:
110 |         t.Commit()
111 |         result_text = "Finished."
112 |         if not reverse:
113 |             result_text += "\nChanged elements saved. To recover then run the same script with SHIFT button"
114 |         TaskDialog.Show(__title__,result_text)
115 | 
116 |     if not is_error:
117 |         save(datafile, saved_list)
118 |     # filter not existing
119 |     selection.set_to([e.Id for e in constraints_to_change
120 |                       if e and e.IsValidObject])
121 | 
122 | 
123 | def main():
124 |     if __shiftclick__:
125 |         reverse = True
126 |     else:
127 |         reverse = False
128 |     datafile, saved_list = get_datafile(reverse)
129 | 
130 |     if not datafile:
131 |         TaskDialog.Show(__title__, "Cancelled")
132 |         return
133 | 
134 |     process(datafile, saved_list, reverse)
135 | 
136 | 
137 | if __name__ == '__main__':
138 |     main()
139 | 


--------------------------------------------------------------------------------
/pyApex.tab/lib/curve_chain.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | import itertools
  3 | from Autodesk.Revit.UI import TaskDialog, TaskDialogCommonButtons
  4 | from pyrevit import script, revit, forms
  5 | import pyapex_utils as pyu
  6 | 
  7 | logger = script.get_logger()
  8 | 
  9 | 
 10 | def pick_chain(doc):
 11 |     selection = revit.selection.get_selection()
 12 |     # last_selection = selection.element_ids
 13 |     selected_curve = revit.pick_element("Select curves to sort by")
 14 | 
 15 |     if not selected_curve:
 16 |         forms.alert("Nothing selected")
 17 |         return None, None
 18 | 
 19 |     logger.debug("selected_curve: %s" % str(selected_curve.Id))
 20 | 
 21 |     try:
 22 |         selected_curve.GeometryCurve
 23 |     except:
 24 |         forms.alert("Error! Selected element is not a Curve.\nOr it have no GeometryCurve parameter")
 25 |         return None, None
 26 | 
 27 |     if not selected_curve.GeometryCurve.IsBound:
 28 |         forms.alert("Error! Curve cannot be bounded")
 29 | 
 30 |     # chain
 31 |     selection_list_sorted, selection_list_sorted_isreversed = _find_curve_chain(selected_curve, doc)
 32 |     logger.debug("selection_list_sorted: %s" % selection_list_sorted)
 33 |     if len(selection_list_sorted) > 1:
 34 |         # TODO undo
 35 |         selection.set_to(selection_list_sorted)
 36 |         form_result = TaskDialog.Show("Select curve chain?", "Curve chain found. Use it?\nIf not, only one selected curve will be used",
 37 |                                       TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No)
 38 | 
 39 |         # selection.set_to(last_selection)
 40 |         if str(form_result) == "Yes":
 41 |             return selection_list_sorted, selection_list_sorted_isreversed
 42 |     logger.debug("Selected_curve: %s" % [selected_curve.Id])
 43 |     return [selected_curve.Id], None
 44 | 
 45 | 
 46 | def _sort_joined_curves_run(curve, doc, end=0):
 47 |     logger.debug("_sort_joined_curves_run, end: %d", end)
 48 |     curves = [curve]
 49 |     result = []
 50 |     result_ids = []
 51 |     result_reversed = []
 52 |     i = 0
 53 | 
 54 |     while len(curves) > 0 and i < 100:
 55 |         _end = end
 56 |         c = curves[0].GeometryCurve
 57 |         # unbound
 58 |         c_id = curves[0].Id
 59 |         logger.debug("%d %d %d" % (i, end, c_id.IntegerValue))
 60 | 
 61 |         if c_id not in result_ids:
 62 | 
 63 |             if len(result) != 0:
 64 |                 c_last = result[-1]
 65 |                 logger.debug("%s=%s" % (c_last.GetEndPoint(end), c.GetEndPoint(end)))
 66 |                 bool_points_equal = pyu.compare_xyz(c_last.GetEndPoint(end), c.GetEndPoint(end), 5)
 67 |             else:
 68 |                 bool_points_equal = False
 69 |             logger.debug("eq %s" % bool_points_equal)
 70 |             if bool_points_equal:
 71 |                 logger.debug("Reverse")
 72 |                 # c = c.CreateReversed()
 73 |                 result_reversed.append(True)
 74 |                 _end = not end
 75 |             else:
 76 |                 result_reversed.append(False)
 77 |             result_ids.append(c_id)
 78 |             result.append(c)
 79 |         else:
 80 |             break
 81 |         curves = map(lambda x: doc.GetElement(x), doc.GetElement(c_id).GetAdjoinedCurveElements(_end))
 82 |         i += 1
 83 | 
 84 |     result_curves = []
 85 |     for i in range(len(result_ids)):
 86 |         c_id = result_ids[i]
 87 |         c = doc.GetElement(c_id).GeometryCurve
 88 |         if result_reversed[i]:
 89 |             logger.debug("reversed")
 90 |             c = c.CreateReversed()
 91 |         result_curves.append(c)
 92 |     return result_ids, result_reversed
 93 | 
 94 | 
 95 | def _find_curve_chain(curve, doc):
 96 |     result, result_is_reversed = _sort_joined_curves_run(curve, doc, 1)
 97 | 
 98 |     result_2, result_is_reversed_2 = _sort_joined_curves_run(curve, doc, 0)
 99 | 
100 |     # combine result
101 |     if len(result_2) > 1:
102 |         result_2 = list(reversed(result_2))[:-1]
103 |         result_is_reversed_2 = list(reversed(result_is_reversed_2))[:-1]
104 |         result = list(itertools.chain(result_2, result))
105 |         result_is_reversed = list(itertools.chain(result_is_reversed_2, result_is_reversed))
106 | 
107 |     return result, result_is_reversed
108 | 
109 | 
110 | def chain_closest_point(point, chain, chain_is_reversed, doc):
111 |     smallest_distance = None
112 |     param = None
113 |     for i in range(len(chain)):
114 |         logger.debug(i)
115 |         c = doc.GetElement(chain[i])
116 |         c_geom = c.GeometryCurve
117 |         int_res = c_geom.Project(point)
118 |         _param = c_geom.ComputeNormalizedParameter(int_res.Parameter)
119 | 
120 |         if chain_is_reversed:
121 |             logger.debug("i: %d, Distance: %f, param: %f, reversed: %s" % (i, int_res.Distance, _param, chain_is_reversed[i]))
122 |             if chain_is_reversed[i]:
123 |                 _param = 1.0 - _param
124 |                 logger.debug("param: %f" % _param)
125 |         else:
126 |             logger.debug(
127 |                 "i: %d, Distance: %f, param: %f, reversed: -" % (i, int_res.Distance, _param))
128 |         if smallest_distance is None or smallest_distance > int_res.Distance:
129 |             # or (i == len(chain) - 1:
130 |             smallest_distance = int_res.Distance
131 |             param = i + _param
132 | 
133 |     return param
134 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils3.stack/LinkDWGsite.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __doc__ = """Create DWG link and orient it to Shared Site Point. As if this DWG had shared coordinates.
  3 | Useful for placing General Plan dwg files with absolute coordinates.
  4 | Shift+Click - enable/disable rotation manually
  5 | 
  6 | Создает DWG связь и размещает ее в Точке Съемки проекта. Как если бы dwg имел общие координаты с моделью.
  7 | Удобно при создании связи с dwg-файлами генплана.
  8 | Shift+Click - включить или выключить поворот вручную
  9 | """
 10 | 
 11 | __title__ = 'Link DWG by Site'
 12 | 
 13 | __helpurl__ = "https://apex-project.github.io/pyApex/help#link-dwg-site"
 14 | 
 15 | import clr
 16 | import System
 17 | clr.AddReference('System')
 18 | 
 19 | try:
 20 |     from pyrevit.versionmgr import PYREVIT_VERSION
 21 | except:
 22 |     from pyrevit import versionmgr
 23 | 
 24 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
 25 | 
 26 | pyRevitNewer44 = PYREVIT_VERSION.major >= 4 and PYREVIT_VERSION.minor >= 5
 27 | 
 28 | from Autodesk.Revit.DB import *
 29 | from Autodesk.Revit.UI import TaskDialog, TaskDialogCommonButtons
 30 | 
 31 | if pyRevitNewer44:
 32 |     from pyrevit import script
 33 |     from pyrevit.forms import pick_file
 34 |     logger = script.get_logger()
 35 |     from pyrevit.revit import doc, selection, uidoc
 36 | 
 37 |     selection = selection.get_selection()
 38 |     my_config = script.get_config()
 39 | else:
 40 |     forms = None
 41 |     from scriptutils import logger
 42 |     from scriptutils.userinput import pick_file
 43 |     from scriptutils import this_script as script
 44 |     from revitutils import doc, selection, uidoc
 45 | 
 46 |     my_config = script.config
 47 | 
 48 | 
 49 | def main():
 50 |     location = doc.ActiveProjectLocation
 51 |     activeview = uidoc.ActiveView
 52 |     project_position = location.get_ProjectPosition(XYZ.Zero)
 53 |     project_angle = project_position.Angle
 54 | 
 55 |     origin = location.GetTotalTransform().Origin
 56 | 
 57 |     # Search for any 3D view or a Plan view
 58 |     cl = FilteredElementCollector(doc)
 59 |     views = cl.OfCategory(BuiltInCategory.OST_Views).WhereElementIsNotElementType().ToElements()
 60 | 
 61 |     q = TaskDialog.Show(__title__, "Link CAD to current view only?",
 62 |                         TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No | TaskDialogCommonButtons.Cancel)
 63 |     if str(q) == "No":
 64 |         this_view_only = False
 65 |         target_view = None
 66 |     elif str(q) == "Yes":
 67 |         this_view_only = True
 68 |         target_view = activeview
 69 |     else:
 70 |         return
 71 | 
 72 |     rotate = False
 73 |     if not target_view:
 74 |         target_view_project = None
 75 |         target_view_3d = None
 76 | 
 77 |         for v in views:
 78 |             if v.IsTemplate:
 79 |                 continue
 80 | 
 81 |             if type(v) == ViewPlan:
 82 |                 orientation = v.get_Parameter(BuiltInParameter.PLAN_VIEW_NORTH)
 83 |                 if orientation.AsInteger() == 1:
 84 |                     target_view = v
 85 |                     break
 86 |                 else:
 87 |                     if not target_view_project:
 88 |                         target_view_project = v
 89 | 
 90 |             if type(v) == View3D and not target_view_3d:
 91 |                 target_view_3d = v
 92 | 
 93 |         if not target_view:
 94 |             rotate = True
 95 |             if target_view_project:
 96 |                 target_view = target_view_project
 97 |             elif target_view_3d:
 98 |                 target_view = target_view_3d
 99 | 
100 |     if not target_view:
101 |         logger.error("Please create 3D view or a PlanView in a project to place CAD correctly")
102 |         return
103 | 
104 |     path = pick_file(files_filter="DWG files (*.dwg)|*.dwg|DXF files (*.dxf)|*.dxf|DGN files (*.dgn)|*.dgn|All files (*.*)|*.*")
105 | 
106 |     if not path:
107 |         return
108 | 
109 |     o = DWGImportOptions()
110 |     o.AutoCorrectAlmostVHLines = False
111 |     o.Unit = ImportUnit.Meter
112 |     o.OrientToView = False
113 |     o.ReferencePoint = origin
114 |     o.ThisViewOnly = this_view_only
115 | 
116 |     link_func = doc.Link.Overloads[str, DWGImportOptions, View, System.Type.MakeByRefType(ElementId)]
117 | 
118 |     t = Transaction(doc)
119 |     t.Start(__title__)
120 |     try:
121 |         status, e_id = link_func(path, o, target_view, )
122 |     except Exception as e:
123 |         logger.error("Unable to import CAD")
124 |         logger.error(e)
125 |         status = False
126 | 
127 |     # override rotation option
128 |     if __shiftclick__:
129 |         q = TaskDialog.Show(__title__, "Is it okay?\nIf not CAD will be rotated",
130 |                                 TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No | TaskDialogCommonButtons.Cancel)
131 |         if str(q) == "No":
132 |             rotate = True
133 |         elif str(q) == "Yes":
134 |             rotate = False
135 |         else:
136 |             return
137 | 
138 |     if status:
139 |         l = doc.GetElement(e_id)
140 |         if rotate:
141 |             if l.Pinned:
142 |                 l.Pinned = False
143 |             axis = Line.CreateBound(origin,
144 |                                     XYZ(origin.X, origin.Y, origin.Z + 1))
145 | 
146 |             ElementTransformUtils.RotateElement(doc, l.Id, axis, -project_angle)
147 |         l.Pinned = True
148 |         t.Commit()
149 |     else:
150 |         t.RollBack()
151 | 
152 | if __name__ == '__main__':
153 |     main()
154 | 
155 | 


--------------------------------------------------------------------------------
/pyApex.tab/Selection.panel/sel1.stack/ExtractIdsText.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __title__ = 'Extract IDs from text'
  3 | __doc__ = """Extracts all elements Ids from pasted text. Useful to select elements from Warnings - just copy text from HTML report.
  4 | Also works with one id per line inputs, e.g. with text copied from spreadsheets.
  5 | 
  6 | Извлекает ID элементов из вставленного текста. Полезно для выбора элементов из отчетов о предупреждениях - просто скопируйте текст из HTML-отчета.
  7 | Также работает с текстом, в котором каждая строка - отдельный ID, например скопированным из таблицы."""
  8 | 
  9 | __helpurl__ = "https://apex-project.github.io/pyApex/help#extract-ids-from-text"
 10 | 
 11 | try:
 12 |     from pyrevit.versionmgr import PYREVIT_VERSION
 13 | except:
 14 |     from pyrevit import versionmgr
 15 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
 16 | 
 17 | pyRevitNewer44 = PYREVIT_VERSION.major >=4 and PYREVIT_VERSION.minor >=5
 18 | 
 19 | if pyRevitNewer44:
 20 |     from pyrevit import script, revit
 21 |     from pyrevit.forms import WPFWindow
 22 |     output = script.get_output()
 23 |     logger = script.get_logger()
 24 |     linkify = output.linkify
 25 |     doc = revit.doc
 26 |     uidoc = revit.uidoc
 27 |     selection = revit.get_selection()
 28 |     datafile = script.get_document_data_file("SelList", "pym")
 29 |     my_config = script.get_config()
 30 | 
 31 | else:
 32 |     from scriptutils import logger
 33 |     from scriptutils import this_script as script
 34 |     from revitutils import doc, uidoc
 35 |     from scriptutils.userinput import WPFWindow
 36 | 
 37 |     my_config = script.config
 38 |     output = script.output
 39 |     datafile = script.get_document_data_file(0, "pym", command_name="SelList")
 40 | 
 41 | import os
 42 | import re
 43 | import pickle as pl
 44 | import clr
 45 | 
 46 | from System.Collections.Generic import List
 47 | from Autodesk.Revit.DB import ElementId
 48 | 
 49 | 
 50 | 
 51 | def addtoclipboard(text):
 52 |     logger.debug('Copying IDs to clipboard')
 53 |     command = 'echo ' + text.strip() + '| clip'
 54 |     os.system(command)
 55 |     logger.debug('Copying IDs to clipboard - OK')
 56 | 
 57 | 
 58 | def strip(value):
 59 |     if value:
 60 |         v = value.strip("\n").strip(" ").strip("\t").strip("\r")
 61 |         if len(v) == 0:
 62 |             return
 63 |         else:
 64 |             return v
 65 |     else:
 66 |         return
 67 | 
 68 | 
 69 | def parse(value, reduce_duplicates = False):
 70 |     value = strip(value)
 71 | 
 72 |     if not value:
 73 |         logger.error("Text is empty")
 74 |         return
 75 | 
 76 |     value_lines = value.split("\n")
 77 | 
 78 |     errors = []
 79 | 
 80 |     ids_str = []
 81 |     ids_element_ids = []
 82 | 
 83 |     for v in range(len(value_lines)):
 84 |         vl = value_lines[v]
 85 |         vl = strip(vl)
 86 | 
 87 |         if not vl:
 88 |             continue
 89 | 
 90 |         _id = None
 91 | 
 92 |         try:
 93 |             _id = int(vl)
 94 |         except:
 95 |             pass
 96 | 
 97 |         if not _id:
 98 |             m = re.search(r"(id|Код)\s+([0-9]{1,})[^0-9]*", vl)
 99 |             try:
100 |                 _id = int(str(m.group(2)))
101 |             except:
102 |                 pass
103 | 
104 |         if _id:
105 |             e_id = ElementId(_id)
106 |             ids_element_ids.append(e_id)
107 |             ids_str.append(str(_id))
108 |         else:
109 |             errors.append("%d: %s" % (v, vl))
110 | 
111 |     if len(ids_element_ids) > 0:
112 |         print('%d elements selected:' % len(ids_element_ids))
113 |         elements_strs = []
114 | 
115 |         if reduce_duplicates:
116 |             ids_element_ids = set(ids_element_ids)
117 |             ids_str = set(ids_str)
118 | 
119 |         for idx, elid in enumerate(ids_element_ids):
120 |             elements_strs.append(output.linkify(elid))
121 |         print(",".join(elements_strs))
122 | 
123 |         # # Copy ids to clipboard
124 |         # addtoclipboard(",".join(set(ids_str)))
125 | 
126 |         # Select objects
127 |         ids_element_ids_list = List[ElementId](ids_element_ids)
128 |         selection = uidoc.Selection
129 |         selection.SetElementIds(ids_element_ids_list)
130 | 
131 |         # Save selection
132 |         try:
133 |             f = open(datafile, 'w')
134 |             pl.dump(ids_str, f)
135 |             f.close()
136 |         except Exception as io_err:
137 |             logger.error('Error read/write to: {} | {}'.format(datafile, io_err))
138 | 
139 |     else:
140 |         print("No IDs were found")
141 | 
142 |     if len(errors) > 0:
143 |         logger.error("Ids weren't found on lines: \n" + "\n".join(errors))
144 | 
145 | 
146 | 
147 | 
148 | 
149 | 
150 | class ExtractIdsTextWindow(WPFWindow):
151 |     def __init__(self, xaml_file_name):
152 |         WPFWindow.__init__(self, xaml_file_name)
153 | 
154 |         self.text.Text = "Paste text from warnings report or any text you want to extract IDs from"
155 | 
156 |         try:
157 |             self.reduce_duplicates.IsChecked = my_config.reduce_duplicates
158 |         except:
159 |             self.reduce_duplicates.IsChecked = my_config.reduce_duplicates = False
160 | 
161 |     # noinspection PyUnusedLocal
162 |     # noinspection PyMethodMayBeStatic
163 |     def send(self, sender, args):
164 |         my_config.reduce_duplicates = self.reduce_duplicates.IsChecked
165 |         script.save_config()
166 |         parse(self.text.Text, reduce_duplicates = self.reduce_duplicates.IsChecked)
167 |         self.Close()
168 | 
169 | 
170 | if __name__ == '__main__':
171 |     ExtractIdsTextWindow('window.xaml').ShowDialog()
172 |     output.set_width(400)
173 |     output.set_height(400)
174 | 


--------------------------------------------------------------------------------
/pyApex.tab/Model.panel/Level.pulldown/RemoveLevel.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __title__ = 'Remove Level Safely\nBETA'
  3 | __doc__ = """Move all elements based on specified level onto another level"""
  4 | 
  5 | __helpurl__ = "https://apex-project.github.io/pyApex/help#remove-level"
  6 | __beta__ = True
  7 | 
  8 | try:
  9 |     from pyrevit.versionmgr import PYREVIT_VERSION
 10 | except:
 11 |     from pyrevit import versionmgr
 12 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
 13 | 
 14 | pyRevitNewer44 = PYREVIT_VERSION.major >=4 and PYREVIT_VERSION.minor >=5
 15 | 
 16 | if pyRevitNewer44:
 17 |     from pyrevit import script, revit
 18 |     from pyrevit.forms import SelectFromList
 19 |     output = script.get_output()
 20 |     logger = script.get_logger()
 21 |     linkify = output.linkify
 22 |     doc = revit.doc
 23 | 
 24 | else:
 25 |     from scriptutils import logger
 26 |     from scriptutils.userinput import SelectFromList
 27 |     from revitutils import doc
 28 | 
 29 | from Autodesk.Revit.DB import *
 30 | 
 31 | 
 32 | class CheckBoxLevel:
 33 |     def __init__(self, level, default_state=False):
 34 |         self.level = level
 35 |         self.name = level.Name
 36 |         self.state = default_state
 37 | 
 38 |     def __str__(self):
 39 |         return self.name
 40 | 
 41 |     def __nonzero__(self):
 42 |         return self.state
 43 | 
 44 |     def __bool__(self):
 45 |         return self.state
 46 | 
 47 | 
 48 | def LevelChangePreselected(selected_ids, target_level_id):
 49 |     errors = []
 50 |     changed = []
 51 |     t = Transaction(doc, 'Change level to 0')
 52 |     t.Start()
 53 |     for e_id in selected_ids:
 54 |         el = doc.GetElement(e_id)
 55 |         try:
 56 |             levelID = el.LevelId  # Initial level of object, assigned on element creation
 57 |             if levelID.IntegerValue < 0:
 58 |                 continue
 59 | 
 60 |             LevelToElement = doc.GetElement(levelID)
 61 | 
 62 |             LevElev = LevelToElement.get_Parameter(BuiltInParameter.LEVEL_ELEV).AsValueString().replace(" ", "")
 63 | 
 64 |             offset = el.get_Parameter(BuiltInParameter.INSTANCE_FREE_HOST_OFFSET_PARAM)
 65 | 
 66 |             if not offset:
 67 |                 offset = el.get_Parameter(BuiltInParameter.FAMILY_BASE_LEVEL_OFFSET_PARAM)
 68 | 
 69 |             if not offset:
 70 |                 offset = el.get_Parameter(BuiltInParameter.WALL_BASE_OFFSET)
 71 | 
 72 |             if not offset:
 73 |                 offset = el.get_Parameter(BuiltInParameter.ROOM_LOWER_OFFSET)
 74 | 
 75 |             print(offset.AsValueString())
 76 |             finalElev = float(LevElev) + float(offset.AsValueString().replace(" ", ""))
 77 |             print(offset.AsValueString(), finalElev)
 78 |             offset.SetValueString(str(finalElev))
 79 | 
 80 |             baselevel = el.get_Parameter(BuiltInParameter.FAMILY_LEVEL_PARAM)
 81 |             if not baselevel:
 82 |                 baselevel = el.get_Parameter(BuiltInParameter.WALL_BASE_CONSTRAINT)
 83 |                 # if baselevel:
 84 |                 #     baseoffset = el.get_Parameter(BuiltInParameter.WALL_BASE_OFFSET)
 85 |                 #     finalOffset = float(LevElev) + float(offset.AsValueString().replace(" ", ""))
 86 |             baselevel.Set(target_level_id)
 87 | 
 88 |             changed.append(str(e_id.IntegerValue))
 89 |         except Exception as e:
 90 |             try:
 91 |                 print("%s %s - %s" % (str(e_id.IntegerValue),str(el.GetType()),str(e)))
 92 |             except:
 93 |                 print("%s - %s" % (str(e_id.IntegerValue), str(e)))
 94 |             errors.append(str(e_id.IntegerValue))
 95 |     t.Commit()
 96 | 
 97 |     return errors, changed
 98 | 
 99 | def main():
100 |     cl = FilteredElementCollector(doc)
101 |     levels_all = cl.OfCategory(BuiltInCategory.OST_Levels).WhereElementIsNotElementType().ToElements()
102 | 
103 |     options = []
104 |     for l in levels_all:
105 |         cb = CheckBoxLevel(l)
106 |         options.append(cb)
107 | 
108 |     if len(options) == 0:
109 |         print("Levels wasn't found")
110 |         return
111 | 
112 |     selected1 = SelectFromList.show(options, title='Select levels to delete', width=300,
113 |                                                button_name='OK', multiselect=True)
114 |     selected_levels1 = [c.level for c in selected1 if c.state == True]
115 | 
116 |     if not selected_levels1:
117 |         print("Nothing selected")
118 |         return
119 | 
120 |     options = [c for c in selected1 if c.state != True]
121 | 
122 |     if len(options) == 0:
123 |         print("You selected all levels")
124 |         return
125 | 
126 |     selected2 = SelectFromList.show(options, title='Select target level', width=300,
127 |                                           button_name='OK')
128 |     if not selected2:
129 |         print("Nothing selected")
130 |         return
131 | 
132 |     selected_levels2 = [c.level for c in selected2]
133 |     target_level = selected_levels2[0]
134 |     errors = set()
135 |     changed = set()
136 |     for l in selected_levels1:
137 |         objects_to_change = []
138 | 
139 |         t = Transaction(doc, "Check level " + l.Name)
140 |         t.Start()
141 |         elements = doc.Delete(l.Id)
142 |         t.RollBack()
143 | 
144 |         errors_, changed_ = LevelChangePreselected(elements, target_level.Id)
145 | 
146 |         errors = errors.union(set(errors_))
147 |         changed = changed.union(set(changed_))
148 | 
149 |     if errors:
150 |         logger.error("Errors")
151 |         logger.error( ",".join(list(errors)))
152 | 
153 |     if changed:
154 |         print("\nChanged succesfully")
155 |         print( ",".join(list(changed)))
156 |     else:
157 |         logger.error("No object were changed")
158 | 
159 | 
160 | if __name__ == '__main__':
161 |     main()
162 | 


--------------------------------------------------------------------------------
/pyApex.tab/Detail.panel/TextNotes2csv.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __doc__ = """Export all textnotes content to csv.
  3 | 
  4 | Context: select views or sheets where you want to search for textnotes
  5 | 
  6 | Экспорт содержимого всех "Текстов" в csv-файл.
  7 | 
  8 | Контекст: выберите виды или листы, на которых необходимо найти тексты
  9 | """
 10 | __title__ = 'TextNotes2csv'
 11 | 
 12 | __helpurl__ = "https://apex-project.github.io/pyApex/help#TextNotes2csv"
 13 | 
 14 | import csv
 15 | import os
 16 | from Autodesk.Revit.DB import *
 17 | from Autodesk.Revit.DB.Architecture import *
 18 | from Autodesk.Revit.UI import TaskDialog, TaskDialogCommonButtons
 19 | 
 20 | 
 21 | try:
 22 |     from pyrevit.versionmgr import PYREVIT_VERSION
 23 | except:
 24 |     from pyrevit import versionmgr
 25 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
 26 | 
 27 | pyRevitNewer44 = PYREVIT_VERSION.major >= 4 and PYREVIT_VERSION.minor >= 5
 28 | 
 29 | if pyRevitNewer44:
 30 |     from pyrevit import script, revit
 31 |     from pyrevit.forms import save_file
 32 |     output = script.get_output()
 33 |     logger = script.get_logger()
 34 |     from pyrevit.revit import doc, uidoc, selection
 35 |     selection = selection.get_selection()
 36 |     my_config = script.get_config()
 37 | 
 38 | else:
 39 |     from scriptutils import logger, this_script as script
 40 |     from scriptutils.userinput import WPFWindow, save_file
 41 |     from revitutils import doc, uidoc, selection
 42 |     my_config = script.config
 43 | 
 44 | 
 45 | def get_views():
 46 |     selection = uidoc.Selection.GetElementIds()
 47 |     views_selected = filter(lambda e: doc.GetElement(e).GetType().IsSubclassOf(View), selection)
 48 | 
 49 |     if len(views_selected) == 0:
 50 |         error_text = "No views selected.\nTextnotes from all project views will be exported."
 51 | 
 52 |         q = TaskDialog.Show(__title__, error_text,
 53 |                             TaskDialogCommonButtons.Ok | TaskDialogCommonButtons.Cancel)
 54 | 
 55 |         if str(q) == "Cancel":
 56 |             return
 57 |         else:
 58 |             return None
 59 | 
 60 |     else:
 61 |         return views_selected
 62 | 
 63 | 
 64 | def extract_views_from_sheets(views):
 65 |     result = []
 66 |     for v in views:
 67 |         if type(view) == ViewSheet:
 68 |             result += v.GetAllPlacedViews()
 69 |         else:
 70 |             result.append(view)
 71 | 
 72 |     return result
 73 | 
 74 | #
 75 | # def views_from_sheet(view):
 76 | #     if type(view) == ViewSheet:
 77 | #         views = s.GetAllPlacedViews()
 78 | #     else:
 79 | #         views = [view]
 80 | #
 81 | #     return views
 82 | 
 83 | 
 84 | def get_textnotes(view_ids=None):
 85 |     collector = FilteredElementCollector(doc)  # collect elements visible on view
 86 |     elements = collector.OfClass(TextNote).ToElements()
 87 | 
 88 |     textnotes_dict = {}
 89 |     unique = []
 90 | 
 91 |     for e in elements:
 92 |         owner_view_id = e.OwnerViewId
 93 | 
 94 |         if view_ids and owner_view_id not in view_ids:
 95 |             continue
 96 | 
 97 |         if e.OwnerViewId not in textnotes_dict.keys():
 98 |             textnotes_dict[e.OwnerViewId] = []
 99 | 
100 |         etext = e.Text.replace('\n', ' ').replace('\r', ' ')
101 | 
102 |         if etext not in unique:
103 |             unique.append(etext)
104 |             textnotes_dict[e.OwnerViewId].append((e.Id, etext))
105 | 
106 |     return textnotes_dict
107 | 
108 | 
109 | def format_results(textnotes_dict):
110 |     cl_sheets = FilteredElementCollector(doc)
111 |     sheetsnotsorted = cl_sheets.OfCategory(BuiltInCategory.OST_Sheets).WhereElementIsNotElementType().ToElements()
112 |     sheetsnotsorted = list(sheetsnotsorted)
113 |     # Last empty element to check not placed views
114 |     sheetsnotsorted.append(None)
115 | 
116 |     result = []
117 | 
118 |     # List of views which wasnt checked
119 |     views_left = textnotes_dict.keys()
120 | 
121 |     for s in sheetsnotsorted:
122 |         if s:
123 |             sheet_views = [s.Id]
124 |             sheet_id = s.Id
125 |             sheet_name = s.Name
126 |             sheet_views += s.GetAllPlacedViews()
127 |         else:
128 |             sheet_name = ""
129 |             sheet_id = ""
130 |             sheet_views = views_left
131 | 
132 |         # todo: search for use of .Parameter[] indexer.
133 |         for v_id in sheet_views:
134 |             if v_id in textnotes_dict:
135 |                 views_left.remove(v_id)
136 | 
137 |                 v = doc.GetElement(v_id)
138 | 
139 |                 tt = textnotes_dict[v_id]
140 | 
141 |                 for t in tt:
142 |                     result.append([sheet_name,sheet_id,
143 |                                    v.Name,v_id,
144 |                                    t[1],t[0]])
145 | 
146 |     return result
147 | 
148 | def write_csv(all_rows):
149 |     default_filename = "textnotes_%s.csv" % doc.Title
150 | 
151 |     try:
152 |         init_dir = my_config.init_dir
153 |         if not os.path.exists(init_dir):
154 |             init_dir = ''
155 |     except:
156 |         init_dir = ''
157 | 
158 |     export_file = save_file(file_ext="csv", init_dir=init_dir, default_name=default_filename)
159 | 
160 |     print('%s\n\nWriting...' % export_file)
161 | 
162 |     with open(export_file, 'w') as f:
163 |         writer = csv.writer(f, delimiter=';', quotechar='"', quoting=csv.QUOTE_MINIMAL, lineterminator='\n')
164 |         writer.writerow(['Sheet', 'SheetID', 'View', 'ViewID', 'Text', 'TextId'])
165 |         writer.writerow([])
166 | 
167 |         for r in all_rows:
168 |             row = []
169 |             for v in r:
170 |                 try:
171 |                     vv = v.ToString()
172 |                 except:
173 |                     vv = str(v)
174 |                 row.append(vv)
175 | 
176 |             writer.writerow([unicode(s).encode("utf-8") for s in row])
177 | 
178 |     print('Completed')
179 | 
180 | 
181 | def main():
182 |     views_selected = get_views()
183 | 
184 |     if views_selected:
185 |         print('%d views selected' % len(views_selected))
186 | 
187 |     textnotes_dict = get_textnotes(views_selected)
188 |     result = format_results(textnotes_dict)
189 |     write_csv(result)
190 | 
191 | 
192 | if __name__ == "__main__":
193 |     main()
194 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils.stack/WhiteMaterials.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*- 
  2 | __doc__ = """Changes appearance of all project materials to 'white' and back. Useful for paper-like render.
  3 | You can set default material (White) and exceptions (Glass, Wood etc.) in command config (run with Shift-click)
  4 | 
  5 | Изменяет отображение всех материалов в проекте на 'белый'. Удобно для создание 'бумажных' визуализаций.
  6 | Для выбора имени материла по-умолчанию и настроек исключений (например, стекло или дерево), запустите с зажатым Shift
  7 | """
  8 | 
  9 | __title__ = 'White Materials'
 10 | __helpurl__ = "https://apex-project.github.io/pyApex/help#white-materials"
 11 | 
 12 | try:
 13 |     from pyrevit.versionmgr import PYREVIT_VERSION
 14 | except:
 15 |     from pyrevit import versionmgr
 16 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
 17 | 
 18 | pyRevitNewer44 = PYREVIT_VERSION.major >=4 and PYREVIT_VERSION.minor >=5
 19 | 
 20 | if pyRevitNewer44:
 21 |     from pyrevit import script, revit
 22 |     from pyrevit.revit import uidoc, doc
 23 |     from pyrevit.forms import CommandSwitchWindow
 24 |     output = script.get_output()
 25 |     logger = script.get_logger()
 26 |     linkify = output.linkify
 27 |     selection = revit.get_selection()
 28 |     my_config = script.get_config()
 29 | 
 30 | else:
 31 |     from scriptutils import logger, this_script as script
 32 |     from revitutils import doc,  uidoc
 33 |     from scriptutils.userinput import CommandSwitchWindow
 34 |     output = script.output
 35 |     my_config = script.config
 36 | 
 37 | import os
 38 | from Autodesk.Revit.DB import *
 39 | from Autodesk.Revit.DB.Architecture import *
 40 | from datetime import datetime
 41 | import re
 42 | import pickle as pl
 43 | 
 44 | 
 45 | def config_ignore_transparent():
 46 |     try:
 47 |         v = my_config.ignore_transparent
 48 |     except:
 49 |         import white_materials_defaults as cdef
 50 |         v = cdef.ignore_transparent
 51 |     return v
 52 | 
 53 | 
 54 | def config_material():
 55 |     try:
 56 |         v = my_config.material
 57 |     except:
 58 |         import white_materials_defaults as cdef
 59 |         v = cdef.material
 60 |     return v
 61 | 
 62 | 
 63 | def config_exceptions():
 64 |     try:
 65 |         v = my_config.exceptions
 66 |     except:
 67 |         import white_materials_defaults as cdef
 68 |         v = cdef.exceptions
 69 |         my_config.exceptions = v
 70 |     return v
 71 | 
 72 | 
 73 | def backup_datafile(f):
 74 |     try:
 75 |         _new_path, ext = os.path.splitext(f)
 76 |         new_path = _new_path + datetime.now().strftime("_%y%m%d_%H-%M-%S") + ext
 77 |         os.rename(f, new_path)
 78 |         logger.debug("Datafile backed up to %s" % new_path)
 79 |     except Exception as e:
 80 |         logger.error("Error renaming datafile\n" + str(e))
 81 | 
 82 | 
 83 | def change_materials(reverse=False, datafile=None, limit=None):
 84 |     mat_dict = {}
 85 | 
 86 |     white_material_name = config_material()
 87 |     materials_exceptions = config_exceptions()
 88 |     ignore_transparent = config_ignore_transparent()
 89 | 
 90 |     if os.path.exists(datafile):
 91 |         logger.debug("Datafile found %s" % datafile)
 92 |         if reverse == False:
 93 |             logger.debug("New materials will be added")
 94 |         f = open(datafile, 'r')
 95 |         mat_dict = pl.load(f)
 96 |         f.close()
 97 |     else:
 98 |         logger.debug("New datafile %s" % datafile)
 99 | 
100 |     cl = FilteredElementCollector(doc)
101 |     mats = list(cl.OfCategory(BuiltInCategory.OST_Materials).WhereElementIsNotElementType().ToElements())
102 | 
103 |     try:
104 |         white_mat = filter(lambda x: x.Name == white_material_name, mats)[0]
105 |     except Exception as e:
106 |         logger.error("Material '%s' not found" % white_material_name)
107 |         logger.error(e)
108 |         return
109 | 
110 |     white_mat_a = white_mat.AppearanceAssetId
111 | 
112 |     logger.info("White material: %s\nAssetId: %d" % (white_material_name, white_mat_a.IntegerValue))
113 | 
114 |     t = Transaction(doc)
115 |     t.Start(__title__ + (" reverse" if reverse else ""))
116 | 
117 |     if limit>0:
118 |         mats = mats[:limit]
119 |     for m in mats:
120 |         m_name = m.Name
121 |         m_name_ignore = False
122 |         for r in materials_exceptions:
123 |             re_match = re.match(r, m_name, re.I)
124 |             if re_match:
125 |                 m_name_ignore = True
126 |                 break
127 | 
128 |         if m_name_ignore:
129 |             logger.info("%s - ignore name" % m_name)
130 |             continue
131 | 
132 |         if m.Transparency != 0 and ignore_transparent:
133 |             logger.info("%s - ignore transparency" % m_name)
134 |             continue
135 | 
136 |         m_id = m.Id.IntegerValue
137 |         a_id = m.AppearanceAssetId.IntegerValue
138 | 
139 |         if reverse == False:
140 |             if a_id != white_mat_a.IntegerValue:
141 |                 mat_dict[m_id] = a_id
142 |                 m.AppearanceAssetId = white_mat_a
143 |                 logger.info("%s (%d, asset %d) changed to white" % (m_name, m_id, a_id))
144 |             else:
145 |                 logger.info("%s (%d) wasn't change" % (m_name, m_id))
146 |         else:
147 |             try:
148 |                 _id = mat_dict[m_id]
149 |                 m.AppearanceAssetId = ElementId(_id)
150 | 
151 |                 logger.info("%s (%d) changed to %d" % (m_name, m_id, _id))
152 |             except:
153 |                 logger.info("%s (%d) not found or wasn't change" % (m_name, m_id))
154 | 
155 |     t.Commit()
156 |     if reverse == False:
157 |         f = open(datafile, 'w')
158 |         pl.dump(mat_dict, f)
159 |         f.close()
160 |     else:
161 |         backup_datafile(datafile)
162 |     print("Completed")
163 | 
164 | 
165 | def main():
166 |     if __forceddebugmode__:
167 |         limit = 10
168 |         logger.debug("limit %d" % limit)
169 |     else:
170 |         limit = None
171 | 
172 |     reverse = False
173 | 
174 |     x,file_name = os.path.split(doc.PathName)
175 |     file_id, x = os.path.splitext(file_name)
176 |     if len(file_id) == 0:
177 |         file_id = doc.Title
178 |     datafile = script.get_data_file(file_id, "pym")
179 | 
180 |     if os.path.exists(datafile):
181 |         options = ["Make White", "Revert original"]
182 |         if pyRevitNewer44:
183 |             selected_switch = CommandSwitchWindow.show(options,
184 |                                                message='Select direction')
185 |         else:
186 |             selected_switch = CommandSwitchWindow(options,
187 |                                                        message='Select direction').pick_cmd_switch()
188 |         if not selected_switch:
189 |             return
190 | 
191 |         if selected_switch == "Revert original":
192 |             reverse = True
193 | 
194 |     change_materials(reverse, datafile=datafile, limit=limit)
195 | 
196 | if __name__ == '__main__':
197 |     main()
198 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils2.stack/ReplaceText.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __title__ = 'Replace text'
  3 | __doc__ = """Find and replace text parameter for selected elements.
  4 | 
  5 | Находит и заменяет текстовые параметры для выделенных элементов"""
  6 | 
  7 | __context__ = 'Selection'
  8 | 
  9 | __helpurl__ = "https://apex-project.github.io/pyApex/help#replace-text"
 10 | 
 11 | from Autodesk.Revit.UI import TaskDialog
 12 | from Autodesk.Revit.DB import BuiltInCategory, ElementId, Definition, StorageType
 13 | 
 14 | from Autodesk.Revit.DB import Transaction, TransactionGroup
 15 | 
 16 | from pyrevit import script
 17 | from pyrevit.forms import WPFWindow, SelectFromList, TemplateListItem
 18 | 
 19 | logger = script.get_logger()
 20 | from pyrevit.revit import doc, selection
 21 | 
 22 | selection = selection.get_selection()
 23 | my_config = script.get_config()
 24 | 
 25 | 
 26 | 
 27 | class CheckBoxParameter(TemplateListItem):
 28 |     @property
 29 |     def name(self):
 30 |         return self.item.Definition.Name
 31 | 
 32 | 
 33 | class ReplaceTextWindow(WPFWindow):
 34 |     def __init__(self, xaml_file_name, selected_elements):
 35 |         self.selection = selected_elements
 36 |         if not self.selection:
 37 |             TaskDialog.Show(__title__, "election error or wrong elements were selected")
 38 |             return
 39 | 
 40 |         parameter_to_set = self.select_parameters()
 41 | 
 42 |         if not parameter_to_set:
 43 |             TaskDialog.Show(__title__, "Nothing selected")
 44 |             return
 45 | 
 46 |         self.parameter_to_set = parameter_to_set
 47 | 
 48 |         WPFWindow.__init__(self, xaml_file_name)
 49 | 
 50 |     @property
 51 |     def text_find(self):
 52 |         return self.textFind.Text
 53 | 
 54 |     @property
 55 |     def text_replace(self):
 56 |         return self.textReplace.Text
 57 | 
 58 |     def run(self, sender, args):
 59 |         text_find = self.text_find
 60 |         text_replace = self.text_replace
 61 |         count_changed = 0
 62 |         t = Transaction(doc, __title__)
 63 |         t.Start()
 64 | 
 65 |         for e in self.selection:
 66 |             definition = self.parameter_to_set.Definition
 67 |             param = e.get_Parameter(definition)
 68 |             param_before = param.AsString()
 69 |             param_after = param_before.replace(text_find, text_replace)
 70 | 
 71 |             if param_before != param_after:
 72 |                 count_changed += 1
 73 |                 self.parameter_value_set(param, param_after)
 74 | 
 75 |         if count_changed:
 76 |             t.Commit()
 77 |             TaskDialog.Show(__title__, "%d of %d elements updated" % (count_changed, len(self.selection),))
 78 |         else:
 79 |             t.RollBack()
 80 |             TaskDialog.Show(__title__, "Nothing was updated")
 81 | 
 82 |     def element_parameter_dict(self, elements, parameter_to_sort):
 83 |         result = {}
 84 |         for e in elements:
 85 |             if type(parameter_to_sort) == str:
 86 |                 if parameter_to_sort[0] == "<" and parameter_to_sort[2:] == " coordinate>":
 87 |                     parameter_loc = parameter_to_sort[1]
 88 |                     loc = e.Location
 89 |                     v = getattr(loc.Point, parameter_loc)
 90 |                 else:
 91 |                     logger.error("Parameter error")
 92 |                     return
 93 |             else:
 94 |                 param = e.get_Parameter(parameter_to_sort.Definition)
 95 |                 v = self.parameter_value_get(param)
 96 |             if v:
 97 |                 result[e] = v
 98 | 
 99 |         return result
100 | 
101 |     def parameter_value_get(self, parameter):
102 |         if not parameter.HasValue:
103 |             return
104 | 
105 |         if parameter.StorageType == StorageType.Double:
106 |             x = float(parameter.AsDouble())
107 |         elif parameter.StorageType == StorageType.Integer:
108 |             x = int(parameter.AsInteger())
109 |         else:
110 |             try:
111 |                 x = float(parameter.AsString().strip().replace(",", "."))
112 |             except:
113 |                 x = parameter.AsString()
114 |         return x
115 | 
116 |     def parameter_value_set(self, parameter, value, text_format=None):
117 |         if parameter.StorageType == StorageType.Double or parameter.StorageType == StorageType.Integer:
118 |             if text_format:
119 |                 try:
120 |                     value = str(float(text_format % value))
121 |                 except:
122 |                     pass
123 |             parameter.SetValueString(value)
124 |         else:
125 |             if text_format:
126 |                 parameter.Set(text_format % value)
127 |             else:
128 |                 parameter.Set(value)
129 | 
130 |     def get_selection_parameters(self, elements):
131 |         """
132 |         Get parameters which are common for all selected elements
133 | 
134 |         :param elements: Elements list
135 |         :return: dict - {parameter_name: Parameter}
136 |         """
137 |         result = {}
138 |         all_parameter_set = set()
139 |         all_parameter_ids_by_element = {}
140 | 
141 |         # find all ids
142 |         for e in elements:
143 |             for p in e.Parameters:
144 |                 p_id = p.Definition.Id
145 |                 all_parameter_set.add(p)
146 | 
147 |                 if e.Id not in all_parameter_ids_by_element.keys():
148 |                     all_parameter_ids_by_element[e.Id] = set()
149 |                 all_parameter_ids_by_element[e.Id].add(p_id)
150 | 
151 |         # filter
152 |         for p in all_parameter_set:
153 |             p_id = p.Definition.Id
154 |             exists_for_all_elements = True
155 |             for e_id, e_params in all_parameter_ids_by_element.items():
156 |                 if p_id not in e_params:
157 |                     exists_for_all_elements = False
158 |                     break
159 | 
160 |             if exists_for_all_elements:
161 |                 result[p.Id] = p
162 | 
163 |         return result
164 | 
165 | 
166 |     def filter_editable(self, parameters):
167 |         """
168 |         Filter parameters which can be modified by users
169 | 
170 |         :param parameters: list of parameters
171 |         :return: filtered list of parameters
172 |         """
173 |         ignore_types = [StorageType.ElementId, ]
174 |         result = {n: p for n, p in parameters.iteritems()
175 |                   if not p.IsReadOnly
176 |                   and p.StorageType not in ignore_types}
177 |         return result
178 | 
179 |     def select_parameters(self):
180 |         parameters_dict = self.get_selection_parameters(self.selection)
181 |         parameters_editable = self.filter_editable(parameters_dict)
182 | 
183 |         options = []
184 |         for param_id, param in parameters_editable.items():
185 |             cb = CheckBoxParameter(param)
186 |             options.append(cb)
187 | 
188 |         selected = SelectFromList.show(options, title='Parameter to replace', width=300,
189 |                                         button_name='OK')
190 | 
191 |         return selected
192 | 
193 | 
194 | def main():
195 |     # Input
196 |     sel = selection.elements
197 |     ReplaceTextWindow('window.xaml', sel).ShowDialog()
198 | 
199 | 
200 | if __name__ == "__main__":
201 |     main()
202 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils3.stack/LinkMore.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __doc__ = """Creates many RVT, DWG or IFC links at once.
  3 | """
  4 | 
  5 | __title__ = 'Link more'
  6 | 
  7 | __helpurl__ = "https://apex-project.github.io/pyApex/help#link-more"
  8 | 
  9 | import clr
 10 | import System
 11 | import os
 12 | clr.AddReference('System')
 13 | 
 14 | from pyrevit import script, revit, forms, HOST_APP
 15 | from Autodesk.Revit.DB import Document, XYZ, Transaction, DWGImportOptions, DGNImportOptions, RevitLinkOptions, RevitLinkType, \
 16 |     RevitLinkInstance, ImportUnit, View, ElementId, ModelPathUtils, UnitSystem, SaveAsOptions
 17 | from pyrevit.revit import doc, selection, uidoc
 18 | 
 19 | logger = script.get_logger()
 20 | output = script.get_output()
 21 | 
 22 | 
 23 | def link_method_cad():
 24 |     files_filter = "DWG files (*.dwg)|*.dwg|DXF files (*.dxf)|*.dxf|DGN files (*.dgn)|*.dgn"
 25 |     files = pick_files(files_filter)
 26 | 
 27 |     # preset
 28 | 
 29 |     origin = doc.ActiveProjectLocation.GetTotalTransform().Origin
 30 |     activeview = uidoc.ActiveView  # or uidoc.ActiveView
 31 | 
 32 |     q = forms.alert("Link CAD to current view only?", yes=True, no=True)
 33 |     if q:
 34 |         this_view_only = True
 35 |         target_view = activeview
 36 |     else:
 37 |         this_view_only = False
 38 |         target_view = None
 39 | 
 40 |     logger.debug("Files")
 41 |     logger.debug(files)
 42 | 
 43 |     for f in files:
 44 |         logger.info("Process file %s ..." % f)
 45 |         link_func = doc.Link.Overloads[str, DWGImportOptions, View, System.Type.MakeByRefType(ElementId)]
 46 | 
 47 |         ext = f[-4:]
 48 |         if ext == ".dwg":
 49 |             o = DWGImportOptions()
 50 |             o.AutoCorrectAlmostVHLines = False
 51 |             o.Unit = ImportUnit.Meter
 52 |             o.OrientToView = False
 53 |             o.ReferencePoint = origin
 54 |             o.ThisViewOnly = this_view_only
 55 |             link_func = doc.Link.Overloads[str, DWGImportOptions, View, System.Type.MakeByRefType(ElementId)]
 56 |         elif ext == ".dgn":
 57 |             o = DGNImportOptions()
 58 |             o.AutoCorrectAlmostVHLines = False
 59 |             o.Unit = ImportUnit.Meter
 60 |             o.OrientToView = False
 61 |             o.ReferencePoint = origin
 62 |             o.ThisViewOnly = this_view_only
 63 |             link_func = doc.Link.Overloads[str, DWGImportOptions, View, System.Type.MakeByRefType(ElementId)]
 64 | 
 65 |         t = Transaction(doc)
 66 |         t.Start(__title__)
 67 |         try:
 68 |             status, e_id = link_func(f, o, target_view, )
 69 |         except Exception as e:
 70 |             logger.error("Unable to import CAD")
 71 |             logger.error(e)
 72 |             status = False
 73 |             e_id = None
 74 |         #
 75 |         # # override rotation option
 76 |         # if __shiftclick__:
 77 |         #     q = TaskDialog.Show(__title__, "Is it okay?\nIf not CAD will be rotated",
 78 |         #                         TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No | TaskDialogCommonButtons.Cancel)
 79 |         #     if str(q) == "No":
 80 |         #         rotate = True
 81 |         #     elif str(q) == "Yes":
 82 |         #         rotate = False
 83 |         #     else:
 84 |         #         return
 85 | 
 86 |         if status:
 87 |             l = doc.GetElement(e_id)
 88 |             # if rotate:
 89 |             #     if l.Pinned:
 90 |             #         l.Pinned = False
 91 |             #     axis = Line.CreateBound(origin,
 92 |             #                             XYZ(origin.X, origin.Y, origin.Z + 1))
 93 |             #
 94 |             #     ElementTransformUtils.RotateElement(doc, l.Id, axis, -project_angle)
 95 |             l.Pinned = True
 96 |             t.Commit()
 97 |         else:
 98 |             t.RollBack()
 99 | 
100 | 
101 | def link_method_rvt():
102 |     files_filter = "RVT files (*.rvt)|*.rvt"
103 |     files = pick_files(files_filter)
104 | 
105 |     for f in files:
106 |         t = Transaction(doc)
107 |         t.Start(__title__)
108 | 
109 |         try:
110 |             mp = ModelPathUtils.ConvertUserVisiblePathToModelPath(f)
111 |             o = RevitLinkOptions(False)
112 |             linkType = RevitLinkType.Create(doc, mp, o)
113 |             instance = RevitLinkInstance.Create(doc, linkType.ElementId)
114 |             status = True
115 |         except Exception as e:
116 |             logger.error("Unable to import RVT")
117 |             logger.error(e)
118 |             status = False
119 |             instance = None
120 | 
121 |         if status:
122 |             instance.Pinned = True
123 |             t.Commit()
124 |         else:
125 |             t.RollBack()
126 | 
127 | 
128 | def link_method_ifc():
129 |     files_filter = "IFC files (*.ifc)|*.ifc"
130 |     files = pick_files(files_filter)
131 |     for f in files:
132 |         t = Transaction(doc)
133 |         t.Start(__title__)
134 |         f_cache = f + ".rvt"
135 |         recreate = not os.path.exists(f_cache)
136 |         logger.debug("Recreate ifc %s = %s" % (f, recreate))
137 |         # try:
138 |         o = RevitLinkOptions(False)
139 |         # create empty doc
140 |         if recreate:
141 |             doc_ifc = HOST_APP.app.OpenIFCDocument(f)
142 |             save_options = SaveAsOptions()
143 |             save_options.OverwriteExistingFile = True
144 |             doc_ifc.SaveAs(f_cache, save_options)
145 |             doc_ifc.Close()
146 | 
147 |         link_load_results = RevitLinkType.CreateFromIFC(doc, f, f_cache, False, o)
148 |         # TODO log results http://www.revitapidocs.com/2019/11b095e1-24d9-91b9-ae2e-004f67c94d6e.htm
149 |         logger.debug(link_load_results.LoadResult)
150 |         instance = RevitLinkInstance.Create(doc, link_load_results.ElementId)
151 |         status = True
152 |         # except Exception as e:
153 |         #     logger.error("Unable to import IFC")
154 |         #     logger.error(e)
155 |         #     status = False
156 |         #     instance = None
157 | 
158 |         if status:
159 |             instance.Pinned = True
160 |             t.Commit()
161 |         else:
162 |             t.RollBack()
163 | 
164 | def link_method_pointcloud():
165 |     files_filter = "Point Cloud project (*.rcp)|*.rcp|Point clouds (*.rcs)|*.rcs"
166 |     files = pick_files(files_filter)
167 | 
168 | 
169 | def pick_files(files_filter):
170 |     logger.debug(files_filter)
171 |     result = []
172 |     for i in range(10):
173 |         paths = forms.pick_file(
174 |             files_filter=files_filter + "|All files (*.*)|*.*",
175 |             restore_dir=True,
176 |             multi_file=True)
177 | 
178 |         if not paths:
179 |             break
180 |         result += list(paths)
181 | 
182 |         logger.info("Files selected: " + "\n".join(paths))
183 | 
184 |         form_result = forms.alert("Add more files?", yes=True, cancel=True)
185 |         if not form_result:
186 |             break
187 | 
188 |     return set(result)
189 | 
190 | 
191 | def method_switch():
192 |     if revit.doc.IsFamilyDocument:
193 |         available_methods_dict = {"CAD": link_method_cad}
194 |     else:
195 |         available_methods_dict = {"CAD": link_method_cad,
196 |                                   "RVT": link_method_rvt,
197 |                                   "IFC": link_method_ifc,
198 |                                   # "PointCloud": link_method_pointcloud
199 |                                   }
200 | 
201 |     selected_switch = forms.CommandSwitchWindow.show(available_methods_dict.keys(), message='Select file type to link')
202 |     return available_methods_dict.get(selected_switch)
203 | 
204 | 
205 | def main():
206 |     func = method_switch()
207 |     if not func:
208 |         return
209 |     data = func()
210 | 
211 | 
212 | if __name__ == '__main__':
213 |     main()
214 | 


--------------------------------------------------------------------------------
/pyApex.tab/Detail.panel/Copy_VG_Filters.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | # pylint: skip-file
  3 | import clr
  4 | import os
  5 | import os.path as op
  6 | import pickle as pl
  7 | 
  8 | from System.Collections.Generic import List
  9 | from Autodesk.Revit.DB import *
 10 | 
 11 | from pyrevit import versionmgr
 12 | 
 13 | 
 14 | __title__ = 'Copy VG filters'
 15 | __helpurl__ = "https://apex-project.github.io/pyApex/help#copy-vg-filters"
 16 | __doc__ = """Copying filter overrides from selected or active view to chosen view templates. 
 17 | If VG override for this filter already exists in a template it will be updated.
 18 | 
 19 | Context: Select or activate a view
 20 | 
 21 | Копирует настройки фильтров из настроек "Переопределения видимости/графики" для текущего вида в выбраныне шеблоны видов.
 22 | Если для фильтра уже заданы переопределения в целевом шаблоне, они будут обновлены.
 23 | 
 24 | Контекст: Выбранный или активный вид
 25 | """
 26 | 
 27 | PYREVIT_VERSION = versionmgr.get_pyrevit_version()
 28 | 
 29 | # if pyrevit is newer than 4.5 (major.minor)
 30 | if PYREVIT_VERSION.major >= 4 and PYREVIT_VERSION.minor >= 5:
 31 |     from pyrevit import script, revit
 32 |     from pyrevit.forms import SelectFromList
 33 |     from pyrevit.revit import doc, uidoc, selection
 34 |     output = script.get_output()
 35 |     logger = script.get_logger()
 36 |     linkify = output.linkify
 37 |     selection = selection.get_selection()
 38 | # otherwise use the older pyrevit api
 39 | else:
 40 |     from scriptutils import logger
 41 |     from scriptutils.userinput import SelectFromList
 42 |     from revitutils import doc, uidoc, selection
 43 | 
 44 | selected_ids = selection.element_ids
 45 | 
 46 | 
 47 | class CheckBoxOption:
 48 |     def __init__(self, name, id, sel_set=[], default_state=False):
 49 |         self.name = name
 50 |         self.id = id
 51 |         self.state = default_state
 52 |         if int(self.id.ToString()) in sel_set:
 53 |             self.state = True
 54 | 
 55 |     # define the __nonzero__ method so you can use your objects in an
 56 |     # if statement. e.g. if checkbox_option:
 57 |     def __nonzero__(self):
 58 |         return self.state
 59 | 
 60 |     # __bool__ is same as __nonzero__ but is for python 3 compatibility
 61 |     def __bool__(self):
 62 |         return self.state
 63 | 
 64 | 
 65 | USER_TEMP = os.getenv('Temp')
 66 | PROJECT_NAME = op.splitext(op.basename(doc.PathName))[0]
 67 | 
 68 | DATAFILE = USER_TEMP + '\\' + PROJECT_NAME + '_pyChecked_Templates.pym'
 69 | logger.debug(DATAFILE)
 70 | 
 71 | sel_set = []
 72 | 
 73 | ALLOWED_TYPES = [
 74 |     ViewPlan,
 75 |     View3D,
 76 |     ViewSection,
 77 |     ViewSheet,
 78 |     ViewDrafting
 79 | ]
 80 | 
 81 | 
 82 | def read_checkboxes_state():
 83 |     try:
 84 |         with open(DATAFILE, 'r') as filter_element: 
 85 |             cursel = pl.load(filter_element)
 86 | 
 87 |         sel_set = []
 88 |         for elId in cursel:
 89 |             sel_set.append(int(elId))
 90 | 
 91 |         return sel_set
 92 |     except:
 93 |         return []
 94 | 
 95 | 
 96 | def save_checkboxes_state(checkboxes):
 97 |     selected_ids = {c.Id.IntegerValue.ToString() for c in checkboxes}
 98 |     with open(DATAFILE, 'w') as filter_element: 
 99 |         pl.dump(selected_ids, filter_element)
100 | 
101 | 
102 | def get_filter_rules(doc):
103 |     return FilteredElementCollector(doc).WhereElementIsNotElementType()\
104 |                                         .OfClass(type(ElementInstance))\
105 |                                         .ToElementIds()
106 | 
107 | 
108 | def get_view_templates(doc, view_type=None, sel_set=sel_set):
109 |     allview_templates = \
110 |         FilteredElementCollector(doc).WhereElementIsNotElementType()\
111 |                                      .OfCategory(BuiltInCategory.OST_Views)\
112 |                                      .ToElementIds()
113 | 
114 |     viewtemplate_list = []
115 |     for vtId in allview_templates:
116 |         vt = doc.GetElement(vtId)
117 |         if vt.IsTemplate:
118 |             if view_type is None or vt.ViewType == view_type:
119 |                 viewtemplate_list.append(vt)
120 |     return viewtemplate_list
121 | 
122 | 
123 | def get_view_filters(doc, view):
124 |     result = []
125 |     for filter_id in view.GetFilters():
126 |         filter_element = doc.GetElement(filter_id)
127 |         result.append(filter_element)
128 |     return result
129 | 
130 | 
131 | def get_active_view():
132 |     if isinstance(doc.ActiveView, View):
133 |         active_view = doc.ActiveView
134 |     else:
135 |         if len(selected_ids) == 0:
136 |             logger.error('Select a view with applied template, to copy filters from it')
137 |             return
138 | 
139 |         active_view = doc.GetElement(selected_ids[0])
140 | 
141 |         if not isinstance(active_view, ALLOWED_TYPES):
142 |             logger.error('Selected view is not allowed. Please select or open view from which '
143 |                          'you want to copy template settings VG Overrides - Filters')
144 |             return
145 |     return active_view
146 | 
147 | 
148 | def main():
149 |     active_view = get_active_view()
150 |     if not active_view:
151 |         logger.warning('Activate a view to copy')
152 |         return
153 | 
154 |     logger.debug('Source view selected: %s id%s' % (active_view.Name, active_view.Id.ToString()))
155 | 
156 |     # Filters selection =======================================================
157 |     active_template_filters_ch = get_view_filters(doc, active_view)
158 | 
159 |     sel_set = read_checkboxes_state()
160 |     viewtemplate_list = get_view_templates(doc, sel_set=sel_set)
161 | 
162 |     if not viewtemplate_list:
163 |         logger.warning('Project has no view templates')
164 |         return
165 | 
166 |     if not active_template_filters_ch:
167 |         logger.warning('Active view has no filter overrides')
168 |         return
169 | 
170 |     filter_checkboxes = \
171 |         SelectFromList.show(
172 |             active_template_filters_ch,
173 |             name_attr='Name',
174 |             title='Select filters to copy',
175 |             button_name='Select filters',
176 |             multiselect=True
177 |         ) or []
178 | 
179 |     filter_checkboxes_sel = []
180 | 
181 |     # Select filters from active view
182 |     for checkbox in filter_checkboxes:
183 |         if checkbox:
184 |             filter_checkboxes_sel.append(checkbox)
185 | 
186 |     if not filter_checkboxes_sel:
187 |         return
188 | 
189 |     # Target view templates selection =========================================
190 |     view_checkboxes = SelectFromList.show(viewtemplate_list, name_attr='Name', title='Select templates to apply filters',
191 |                                           button_name='Apply filters to templates', multiselect=True)
192 |     view_checkboxes_sel = []
193 | 
194 |     # Select view templates to copy
195 |     for checkbox in view_checkboxes:
196 |         if checkbox:
197 |             view_checkboxes_sel.append(checkbox)
198 | 
199 |     if not view_checkboxes_sel:
200 |         return
201 | 
202 |     save_checkboxes_state(view_checkboxes_sel)
203 | 
204 |     # active_template = doc.GetElement(active_view.ViewTemplateId)
205 | 
206 |     t = Transaction(doc)
207 |     t.Start(__title__)
208 | 
209 |     for vt in view_checkboxes_sel:
210 |         if vt.Id == active_view.ViewTemplateId:
211 |             logger.debug('Current template found')
212 |             continue
213 | 
214 |         for filter_element in filter_checkboxes_sel:
215 |             try:
216 |                 vt.RemoveFilter(filter_element.Id)
217 |                 logger.debug('filter %s deleted from template %s' % (filter_element.Id.IntegerValue.ToString(), vt.Name))
218 |             except:
219 |                 pass
220 | 
221 |             try:
222 |                 fr = active_view.GetFilterOverrides(filter_element.Id)
223 |                 vt.SetFilterOverrides(filter_element.Id, fr)
224 |             except Exception as e:
225 |                 logger.warning('filter %s was not aplied to view %s\n%s' % (filter_element.Id.IntegerValue.ToString(),
226 |                                                                             vt.Name, e))
227 | 
228 |     t.Commit()
229 | 
230 |     print("Completed")
231 | 
232 | if __name__ == "__main__":
233 |     main()
234 | 


--------------------------------------------------------------------------------
/pyApex.tab/QualityControl.panel/GridAngle.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | 
  3 | __doc__ = """Check angles between grids. Help to find not-accurately placed grids and outliers
  4 | 
  5 | Позволяет найти отклонившиеся оси.
  6 | """
  7 | __title__ = 'Grid Angles'
  8 | __helpurl__ = "https://apex-project.github.io/pyApex/help#grid-angles"
  9 | try:
 10 |     from pyrevit.versionmgr import PYREVIT_VERSION
 11 |     pyRevitNewer44 = PYREVIT_VERSION.major >=4 and PYREVIT_VERSION.minor >=5
 12 | except:
 13 |     from pyrevit import versionmgr
 14 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
 15 |     pyRevitNewer44 = True
 16 | 
 17 | if pyRevitNewer44:
 18 |     from pyrevit import script, revit
 19 |     logger = script.get_logger()
 20 |     output = script.get_output()
 21 |     linkify = output.linkify
 22 |     selection = revit.get_selection()
 23 |     doc = revit.doc
 24 |     uidoc = revit.uidoc
 25 | 
 26 | else:
 27 |     from scriptutils import logger
 28 |     from scriptutils import this_script
 29 |     linkify = this_script.output.linkify
 30 |     uidoc = __revit__.ActiveUIDocument
 31 |     doc = uidoc.Document
 32 | 
 33 | import math
 34 | import itertools
 35 | from Autodesk.Revit.UI import TaskDialog, TaskDialogCommonButtons
 36 | from Autodesk.Revit.DB import *
 37 | from Autodesk.Revit.DB.Architecture import *
 38 | 
 39 | 
 40 | def get_grids(view_id = None, ids=False):
 41 |     if view_id:
 42 |         cl = FilteredElementCollector(doc, view_id)
 43 |     else:
 44 |         cl = FilteredElementCollector(doc)
 45 |     grids = cl.OfCategory(BuiltInCategory.OST_Grids).WhereElementIsNotElementType()
 46 | 
 47 |     if ids:
 48 |         return grids.ToElementIds()
 49 |     else:
 50 |         return grids.ToElements()
 51 | 
 52 | 
 53 | def curve_angle(crv, mode="deg", precision_max=5):
 54 |     pt_start = crv.GetEndPoint(0)
 55 |     pt_end = crv.GetEndPoint(1)
 56 |     x = abs(pt_start.X - pt_end.X)
 57 |     y = abs(pt_start.Y - pt_end.Y)
 58 |     if x==0:
 59 |         rad = 0
 60 |     else:
 61 |         rad = math.atan(y/x)
 62 |     k = 1
 63 |     if pt_start.X < pt_end.X:
 64 |         k *= -1
 65 |     if pt_start.Y < pt_end.Y:
 66 |         k *= -1
 67 |     rad = rad * k
 68 | 
 69 |     if mode == "deg":
 70 |         return round(math.degrees(rad) % 90, precision_max)
 71 |     else:
 72 |         return round(rad % (math.pi / 2), precision_max+3)
 73 | 
 74 | 
 75 | def group_runs(li,precision=2):
 76 |     out = []
 77 |     li = list(li)
 78 |     li.sort()
 79 |     last_min = li[0]
 80 |     for x in li:
 81 |         if abs(x-last_min) > precision:
 82 |             yield out
 83 |             out = []
 84 |             last_min = x
 85 | 
 86 |         out.append(x)
 87 | 
 88 |     yield out
 89 | 
 90 | curve_angles = {}
 91 | 
 92 | 
 93 | def group_grids(grids, precision = 2):
 94 |     groups_no_round = {}
 95 |     groups = {}
 96 | 
 97 |     for g in grids:
 98 |         d = curve_angle(g.Curve)
 99 |         curve_angles[g.Id] = d
100 | 
101 |         if d not in groups_no_round.keys():
102 |             groups_no_round[d] = []
103 |         groups_no_round[d].append(g)
104 | 
105 |     keys = list(groups_no_round.keys())
106 | 
107 |     keys_groups = list(group_runs(keys, precision))
108 | 
109 |     for kg in keys_groups:
110 |         if kg[0] not in groups.keys():
111 |             groups[kg[0]] = []
112 |         for k in kg:
113 |             groups[kg[0]] += groups_no_round[k]
114 | 
115 |     return groups
116 | 
117 | 
118 | def find_outlier_grids(grids_grouped):
119 |     group_outliers = {}
120 | 
121 |     result = []
122 | 
123 |     for k,vv in grids_grouped.items():
124 | 
125 |         if k not in group_outliers.keys():
126 |             group_outliers[k] = {}
127 | 
128 |         for v in vv:
129 |             d = curve_angles[v.Id]
130 |             if d not in group_outliers[k].keys():
131 |                 group_outliers[k][d] = []
132 |             group_outliers[k][d].append(v.Id)
133 | 
134 |         if len(group_outliers[k].keys()) == 1:
135 |             continue
136 | 
137 |         # Sort precise grid groups by length - how many grids in each of them
138 |         angles_sorted = sorted(group_outliers[k].keys(),
139 |                                key=lambda x: len(group_outliers[k][x]),
140 |                                reverse=True)
141 |         ids_good = []
142 |         ids_bad = []
143 | 
144 |         for i in range(len(angles_sorted)):
145 |             v = angles_sorted[i]
146 | 
147 |             if i == 0 and len(group_outliers[k][v]) > 1:
148 |                 ids_good += group_outliers[k][v]
149 |             else:
150 |                 ids_bad += group_outliers[k][v]
151 | 
152 | 
153 |         result.append([ids_good,ids_bad])
154 | 
155 |     return result
156 | 
157 | 
158 | def get_design_options(doc):
159 |     cl = FilteredElementCollector(doc)
160 | 
161 |     design_options = cl.OfClass(DesignOption).WhereElementIsNotElementType().ToElements()
162 |     if len(design_options) == 0:
163 |         return
164 | 
165 |     do_dict = {}
166 |     for do in design_options:
167 |         s_id = do.get_Parameter(BuiltInParameter.OPTION_SET_ID).AsElementId()
168 |         if s_id not in do_dict.keys():
169 |             do_dict[s_id] = []
170 |         do_dict[s_id].append(do.Id)
171 | 
172 |     return do_dict
173 | 
174 | 
175 | def check_element_designoption(element, design_options):
176 |     do = element.get_Parameter(BuiltInParameter.DESIGN_OPTION_ID).AsElementId()
177 | 
178 |     return do == ElementId(-1) or do in design_options
179 | 
180 | 
181 | def group_by_design_options(elements, design_options_dict):
182 |     combinations = list(itertools.product(*list(design_options_dict.values())))
183 | 
184 |     result = []
185 |     for c in combinations:
186 |         els = filter(lambda e: check_element_designoption(e,c), elements)
187 |         result.append(list(els))
188 | 
189 |     return result
190 | 
191 | 
192 | def run(interactive=False):
193 |     if interactive:
194 |         text = "Run Grid angles check?"
195 |         a = TaskDialog.Show(__title__, text,
196 |             TaskDialogCommonButtons.Yes|TaskDialogCommonButtons.Cancel)
197 | 
198 |         if str(a) != "Yes":
199 |             return
200 | 
201 |         # if type(doc.ActiveView) == ViewPlan:
202 |         #     text += "\n\nПерекрасить ошибочные оси на текущем плане \"%s\"?"
203 | 
204 |     grids = get_grids()
205 |     grids_linear = filter(lambda x: not x.IsCurved, grids)
206 | 
207 |     design_options_dict = get_design_options(doc)
208 | 
209 |     if design_options_dict:
210 |         elements_by_do = group_by_design_options(grids_linear, design_options_dict)
211 |     else:
212 |         elements_by_do = [grids_linear,]
213 | 
214 |     ids_bad_to_override = []
215 |     ids_orphaned = []
216 | 
217 |     for i in range(len(elements_by_do)):
218 |         if len(elements_by_do) > 1:
219 |             print("Design options combination %d" % (i + 1))
220 |         grids_do = elements_by_do[i]
221 |         logger.debug(grids_do)
222 |         grids_grouped = group_grids(grids_do, precision = 2)
223 | 
224 |         outliers = find_outlier_grids(grids_grouped)
225 | 
226 |         for grids_group in outliers:
227 |             if len(grids_group) != 2:
228 |                 continue
229 |             ids_good, ids_bad = grids_group
230 | 
231 |             if len(ids_bad) == 0:
232 |                 continue
233 |             ids_bad_to_override += ids_bad
234 | 
235 |             if len(ids_good) > 0:
236 |                 good_id = ids_good[0]
237 |                 print("Outliers from grid \"%s\" %s:" % ( doc.GetElement(good_id).Name, \
238 |                                                     linkify(good_id) ) )
239 |             else:
240 |                 good_id = None
241 |                 print("Orphaned grids:" )
242 | 
243 |             for g_id in ids_bad:
244 |                 g_name = doc.GetElement(g_id).Name
245 |                 if good_id:
246 |                     print("\"%s\" ( %s&deg; ) %s " % (g_name, \
247 |                                             curve_angles[g_id] - curve_angles[good_id], linkify(g_id), ) )
248 |                 else:
249 |                     print("\"%s\" %s " % (g_name, linkify(g_id), ) )
250 | 
251 |             print("\n\n")
252 | 
253 |     if type(doc.ActiveView) == ViewPlan and len(ids_bad_to_override) > 0:
254 |         text = "Check completed\n%d errors found. Mark outliers grids on active plan view \"%s\"?" %(len(ids_bad_to_override), doc.ActiveView.Name)
255 |         a = TaskDialog.Show(__title__, text,
256 |             TaskDialogCommonButtons.Yes|TaskDialogCommonButtons.No)
257 | 
258 |         if a == "No":
259 |             return
260 | 
261 |         override_gray = OverrideGraphicSettings() \
262 |             .SetProjectionLineColor(Color(200,200,200))
263 | 
264 |         override_red = OverrideGraphicSettings().SetProjectionLineColor(Color(255,0,0)) \
265 |             .SetProjectionLineWeight(6)
266 | 
267 |         t = Transaction(doc)
268 |         t.Start("Override graphics")
269 | 
270 |         for g in grids:
271 |             doc.ActiveView.SetElementOverrides(g.Id, override_gray)
272 | 
273 |         grids_visible = get_grids(doc.ActiveView.Id, ids=True)
274 | 
275 |         for g in ids_bad_to_override:
276 |             if g not in grids_visible:
277 |                 line = doc.Create.NewDetailCurve(doc.ActiveView, doc.GetElement(g).Curve )
278 |                 doc.ActiveView.SetElementOverrides(line.Id, override_red)
279 |             doc.ActiveView.SetElementOverrides(g, override_red)
280 | 
281 |         t.Commit()
282 | 
283 |     if len(ids_bad_to_override) == 0:
284 |         TaskDialog.Show(__title__, "Check completed\n0 errors")
285 | 
286 | if __name__ == '__main__':
287 |     run(interactive=True)
288 | 


--------------------------------------------------------------------------------
/pyApex.tab/QualityControl.panel/Links.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*- 
  2 | __doc__ = """
  3 | Checks are links pinned, shared site disabled and that link located on separated workset (started from 00_). 
  4 | Fix these issues (except Shared site - should be fixed manually)
  5 | 
  6 | Проверяет закреплены ли связи, отключена ли Общая площадка и находится ли связь на отдельном рабочем наборе (начинающемся с 00_)
  7 | Исправляет эти ошибки (за исключением Общей площадки - нужно исправлять вручную)
  8 | """
  9 | 
 10 | __title__ = 'Links'
 11 | __helpurl__ = "https://apex-project.github.io/pyApex/help#links"
 12 | try:
 13 |     from pyrevit.versionmgr import PYREVIT_VERSION
 14 | 
 15 |     pyRevitNewer44 = PYREVIT_VERSION.major >= 4 and PYREVIT_VERSION.minor >= 5
 16 | 
 17 | except:
 18 |     from pyrevit import versionmgr
 19 | 
 20 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
 21 |     pyRevitNewer44 = True
 22 | 
 23 | if pyRevitNewer44:
 24 |     from pyrevit import script, revit
 25 | 
 26 |     logger = script.get_logger()
 27 |     output = script.get_output()
 28 |     linkify = output.linkify
 29 |     selection = revit.get_selection()
 30 |     doc = revit.doc
 31 |     uidoc = revit.uidoc
 32 | else:
 33 |     from scriptutils import logger
 34 |     from scriptutils import this_script
 35 | 
 36 |     linkify = this_script.output.linkify
 37 |     uidoc = __revit__.ActiveUIDocument
 38 |     doc = uidoc.Document
 39 | 
 40 | from Autodesk.Revit.UI import TaskDialog, TaskDialogCommonButtons
 41 | from Autodesk.Revit.DB import *
 42 | import re
 43 | import os
 44 | 
 45 | cl = FilteredElementCollector(doc).WhereElementIsElementType()
 46 | selection = cl.OfCategory(BuiltInCategory.OST_RvtLinks).ToElementIds()
 47 | 
 48 | 
 49 | def file2ws_name(filename):
 50 |     symbols = (u"абвгдеёжзийклмнопрстуфхцчшщъыьэюяАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ",
 51 |                u"abvgdeejzijklmnoprstufhzcss_y_euaABVGDEEJZIJKLMNOPRSTUFHZCSS_Y_EUA")
 52 | 
 53 |     tr = {ord(a): ord(b) for a, b in zip(*symbols)}
 54 | 
 55 |     filename, ext = os.path.splitext(filename)
 56 |     ext = ext.replace('.', '')
 57 |     filename = re.sub(r'[^a-zA-Zа-яА-Я0-9_-]', '_', filename)
 58 |     filename = filename.translate(tr)
 59 | 
 60 |     return "00_{ext}_{filename}".format(ext=ext, filename=filename).upper()
 61 | 
 62 | 
 63 | class Check(object):
 64 |     def __init__(self, elements):
 65 | 
 66 |         self.elements = elements
 67 |         self.errors = {}
 68 |         self.fix_text = "Fix these warnings?"
 69 | 
 70 |     def run(self):
 71 |         self.check_all()
 72 |         if len(self.errors.keys()) > 0:
 73 |             error_text = self.fix_text + "\n\n" + "\n\n".join(list(self.errors.keys()))
 74 | 
 75 |             q = TaskDialog.Show(type(self).__name__, error_text,
 76 |                                 TaskDialogCommonButtons.Ok | TaskDialogCommonButtons.Cancel)
 77 |             if str(q) == "Ok":
 78 |                 self.fix()
 79 | 
 80 |     def check_all(self):
 81 |         for k in self.elements.keys():
 82 |             els = self.elements[k]
 83 |             for e in els:
 84 |                 self.check_one(e, k)
 85 | 
 86 |     def check_one(self, e):
 87 |         pass
 88 | 
 89 |     def fix(self):
 90 |         pass
 91 | 
 92 | 
 93 | class CheckPinned(Check):
 94 |     def __init__(self, elements):
 95 |         super(self.__class__, self).__init__(elements)
 96 | 
 97 |     def check_one(self, e, k):
 98 |         t = doc.GetElement(k)
 99 |         filename = t.get_Parameter(BuiltInParameter.ALL_MODEL_TYPE_NAME).AsString()
100 |         is_nested = doc.GetElement(e.GetTypeId()).IsNestedLink
101 | 
102 |         if e.Pinned == False and not is_nested:
103 |             message = '%s instance not pinned' % (filename,)
104 |             if message not in self.errors:
105 |                 self.errors[message] = []
106 |             self.errors[message].append(e)
107 | 
108 |     def fix(self):
109 |         t = Transaction(doc, 'Fix links - Pin')
110 |         t.Start()
111 |         for vv in self.errors.values():
112 |             for e in vv:
113 |                 e.Pinned = True
114 |         t.Commit()
115 | 
116 | 
117 | class SaveSharedCoordinatesCallback(ISaveSharedCoordinatesCallback):
118 |     def GetSaveModifiedLinksOption(self, link):
119 |         return SaveModifiedLinksOptions.DisableSharedPositioning
120 | 
121 |     def __init__(self):
122 |         pass
123 | 
124 | 
125 | class CheckShared(Check):
126 |     def __init__(self, elements):
127 |         super(self.__class__, self).__init__(elements)
128 |         self.fix_text = "Disable Shared coordinates manually:"
129 | 
130 |     def check_one(self, e, k):
131 |         t = doc.GetElement(k)
132 |         filename = t.get_Parameter(BuiltInParameter.ALL_MODEL_TYPE_NAME).AsString()
133 |         is_nested = doc.GetElement(e.GetTypeId()).IsNestedLink
134 | 
135 |         if not is_nested and "<" not in e.Name:
136 |             message = '%s has shared position enabled' % (filename,)
137 |             if message not in self.errors:
138 |                 self.errors[message] = []
139 |             self.errors[message].append(e)
140 | 
141 |     def fix(self):
142 |         pass
143 |         # t = Transaction(doc, 'Fix links - Shared coordinates')
144 |         # t.Start()
145 |         # for vv in self.errors.values():
146 |         #     for e in vv:
147 |         #         is_nested = doc.GetElement(e.GetTypeId()).IsNestedLink
148 |         #         if is_nested:
149 |         #             continue
150 |         #         type_id = e.GetTypeId()
151 |         #         type_el = doc.GetElement(type_id)
152 |         #         translation = XYZ(1, 0, 0)
153 |         #         print(e.GetTotalTransform().BasisX, e.GetTotalTransform().BasisY, e.GetTotalTransform().BasisZ,
154 |         #               e.GetTotalTransform().Determinant, e.GetTotalTransform().Origin)
155 |         #         try:
156 |         #             ElementTransformUtils.MoveElement(doc, e.Id, translation)
157 |         #         except:
158 |         #             print("Move failed")
159 |         #         print(type_el)
160 |         #         print(type_el.SavePositions(SaveSharedCoordinatesCallback()))
161 |         # t.RollBack()
162 | 
163 | 
164 | class CheckWorkset(Check):
165 |     def __init__(self, elements):
166 |         super(self.__class__, self).__init__(elements)
167 |         self.allowed_pattern = r"(A[-_]{1}LNK|\.|00[-_]{1}|01[-_]{1}|#)"
168 |         _all_worksets = FilteredWorksetCollector(doc).OfKind(WorksetKind.UserWorkset).ToWorksets()
169 |         self.all_worksets = {}
170 | 
171 |         for w in _all_worksets:
172 |             self.all_worksets[w.Id.IntegerValue] = w.Name
173 | 
174 |     def check_one(self, e, k):
175 |         ws_name = self.all_worksets[e.WorksetId.IntegerValue]
176 |         m = re.match(self.allowed_pattern, ws_name, re.I)
177 |         ws_name_type = self.all_worksets[doc.GetElement(e.GetTypeId()).WorksetId.IntegerValue]
178 |         m_type = re.match(self.allowed_pattern, ws_name_type, re.I)
179 |         is_nested = doc.GetElement(e.GetTypeId()).IsNestedLink
180 |         if (not m or not m_type) and not is_nested:
181 |             t = doc.GetElement(k)
182 |             filename = t.get_Parameter(BuiltInParameter.ALL_MODEL_TYPE_NAME).AsString()
183 |             ws_name_new = file2ws_name(filename)
184 |             message = '%s in %s --> %s' % (filename, ws_name, ws_name_new,)
185 |             if message not in self.errors:
186 |                 self.errors[message] = []
187 |             self.errors[message].append((e, ws_name_new))
188 | 
189 |     #
190 |     def fix(self):
191 |         needed_workset = set()
192 |         [[needed_workset.add(v[1]) for v in vv] for vv in self.errors.values()]
193 |         t = Transaction(doc, 'Workset creation')
194 |         t.Start()
195 |         for ws in needed_workset:
196 |             if ws not in self.all_worksets.values():
197 |                 print("new workset %s" % ws)
198 |                 ws_new = Workset.Create(doc, ws)
199 |                 self.all_worksets[ws_new.Id.IntegerValue] = ws
200 |                 # e, new_value = self.errors[k]
201 |         t.Commit()
202 |         t = Transaction(doc, 'Workset change')
203 |         t.Start()
204 |         all_worksets_inv = {v: k for k, v in self.all_worksets.iteritems()}
205 | 
206 |         for vv in self.errors.values():
207 |             for e, ws_name_new in vv:
208 |                 is_nested = doc.GetElement(e.GetTypeId()).IsNestedLink
209 |                 if is_nested:
210 |                     continue
211 | 
212 |                 wsparam = e.get_Parameter(BuiltInParameter.ELEM_PARTITION_PARAM)
213 |                 if (wsparam == None):
214 |                     continue
215 |                 wsparam.Set(all_worksets_inv[ws_name_new])
216 |                 # Update type workset
217 |                 wsparam = doc.GetElement(e.GetTypeId()).get_Parameter(BuiltInParameter.ELEM_PARTITION_PARAM)
218 |                 if (wsparam == None):
219 |                     continue
220 |                 wsparam.Set(all_worksets_inv[ws_name_new])
221 | 
222 |         t.Commit()
223 | 
224 | 
225 | def collect_links():
226 |     """
227 |     Collects links from model in format
228 |     { LinkType: [LinkInstance, LinkInstance, ... ] }
229 | 
230 |     :return:
231 |     dict
232 |     """
233 | 
234 |     links = {}
235 | 
236 |     cl = FilteredElementCollector(doc).OfCategory(
237 |         BuiltInCategory.OST_RvtLinks).WhereElementIsNotElementType().ToElementIds()
238 |     for e_id in cl:
239 |         e = doc.GetElement(e_id)
240 |         type_id = e.GetTypeId()
241 |         if type_id not in links:
242 |             links[type_id] = []
243 |         links[type_id].append(e)
244 | 
245 |     return links
246 | 
247 | 
248 | def main():
249 |     links = collect_links()
250 |     if doc.IsWorkshared:
251 |         CheckWorkset(links).run()
252 |     CheckPinned(links).run()
253 |     CheckShared(links).run()
254 | 
255 | 
256 | if __name__ == '__main__':
257 |     main()


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/ShowDependent.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __title__ = 'Show\nDependent'
  3 | __doc__ = """List elements dependent on selected levels. To setup exceptions and limit run with Shift-click.
  4 | 
  5 | Выдает список элементов, зависимых от выбранных видов. Для настроек исключения и ограничения кол-ва элементов, которые выводятся в списке, запустите с зажатым Shift"""
  6 | 
  7 | __helpurl__ = "https://apex-project.github.io/pyApex/help#show-dependent"
  8 | 
  9 | from pyrevit import script, revit
 10 | from pyrevit.revit import uidoc, doc
 11 | from pyrevit.forms import SelectFromList, CommandSwitchWindow, alert, TemplateListItem
 12 | output = script.get_output()
 13 | logger = script.get_logger()
 14 | linkify = output.linkify
 15 | selection = revit.get_selection()
 16 | my_config = script.get_config()
 17 | 
 18 | 
 19 | from Autodesk.Revit.DB import *
 20 | from Autodesk.Revit.UI import TaskDialog, TaskDialogCommonButtons
 21 | import operator
 22 | 
 23 | def config_exceptions():
 24 |     try:
 25 |         v = my_config.exceptions
 26 |     except:
 27 |         import show_dependent_defaults as cdef
 28 |         v = cdef.exceptions
 29 | 
 30 |         my_config.exceptions = v
 31 |         script.save_config()
 32 | 
 33 |     return v
 34 | 
 35 | 
 36 | def config_limit():
 37 |     try:
 38 |         v = my_config.limit
 39 |     except:
 40 |         import show_dependent_defaults as cdef
 41 |         v = cdef.limit
 42 | 
 43 |         my_config.limit = v
 44 |         script.save_config()
 45 | 
 46 |     return v
 47 | 
 48 | def config_ignore_selected():
 49 |     try:
 50 |         v = my_config.ignore_selected
 51 |     except:
 52 |         import show_dependent_defaults as cdef
 53 |         v = cdef.ignore_selected
 54 | 
 55 |         my_config.ignore_selected = v
 56 |         script.save_config()
 57 | 
 58 |     return v
 59 | 
 60 | 
 61 | def all_levels():
 62 |     cl = FilteredElementCollector(doc)
 63 |     all = cl.OfCategory(BuiltInCategory.OST_Levels).WhereElementIsNotElementType().ToElements()
 64 |     all_sorted = sorted(all, key=lambda l: l.Name)
 65 |     return all_sorted
 66 | 
 67 | 
 68 | def all_worksets():
 69 |     cl = FilteredWorksetCollector(doc)
 70 |     all = cl.OfKind(WorksetKind.UserWorkset)
 71 |     all_sorted = sorted(all, key=lambda l:l.Name)
 72 |     return all_sorted
 73 | 
 74 | 
 75 | def select_levels_dialog(elements_all, name = "parent object"):
 76 |     selected = SelectFromList.show(elements_all, name_attr='Name', title='Select %s to check' % name, width=300,
 77 |                                          button_name='Select', multiselect=True)
 78 |     return selected
 79 | 
 80 | 
 81 | def check_dependent_views(l):
 82 |     to_close = []
 83 | 
 84 |     for uiview in uidoc.GetOpenUIViews():
 85 |         v = doc.GetElement(uiview.ViewId)
 86 |         if not v.GenLevel:
 87 |             continue
 88 | 
 89 |         if v.GenLevel.Id == l.Id:
 90 |             to_close.append(uiview)
 91 | 
 92 |     return to_close
 93 | 
 94 | 
 95 | def starting_view():
 96 |     startingViewSettingsCollector = FilteredElementCollector(doc)
 97 |     startingViewSettingsCollector.OfClass(StartingViewSettings).ToElements()
 98 |     startingView = None
 99 | 
100 |     for settings in startingViewSettingsCollector:
101 |         startingView = doc.GetElement(settings.ViewId)
102 | 
103 |     logger.debug("Starting view", startingView)
104 |     return startingView
105 | 
106 | 
107 | def group_by_type(elements_ids):
108 |     ignore_types = config_exceptions()
109 | 
110 |     result_dict = {}
111 | 
112 |     for e_id in elements_ids:
113 |         e = doc.GetElement(e_id)
114 |         if not e:
115 |             continue
116 | 
117 |         try:
118 |             el_type = e.Category.Name
119 |         except:
120 |             el_type = "Other"
121 | 
122 |         
123 | 
124 |         if el_type in ignore_types:
125 |             continue
126 | 
127 |         el_type_full = el_type + " - " + e.GetType().Name.ToString()
128 |         if el_type_full not in result_dict:
129 |             result_dict[el_type_full] = []
130 |         result_dict[el_type_full].append(e_id)
131 | 
132 |     return result_dict
133 | 
134 | 
135 | def level_dependent():
136 |     """By level"""
137 |     levels_all = all_levels()
138 |     if len(levels_all) < 2:
139 |         print("At least 2 levels should be created in a project to check dependent. Create one more level and run again")
140 |         return
141 | 
142 |     selected_levels = select_levels_dialog(levels_all)
143 |     if not selected_levels:
144 |         print("Nothing selected")
145 |         return
146 | 
147 |     results = {}
148 |     for e in selected_levels:
149 |         views_to_close = check_dependent_views(e)
150 |         if len(views_to_close) > 0:
151 | 
152 |             q = TaskDialog.Show(__title__,
153 |                                 "These views will be closed:\n%s" % ", ".join(
154 |                                     map(lambda x: doc.GetElement(x.ViewId).Name, views_to_close) ),
155 |                                 TaskDialogCommonButtons.Ok | TaskDialogCommonButtons.Cancel)
156 | 
157 |             if str(q) == "Cancel":
158 |                 break
159 | 
160 |             if len(uidoc.GetOpenUIViews()) == len(views_to_close):
161 |                 uidoc.ActiveView = starting_view()
162 | 
163 |             for v in views_to_close:
164 |                 v.Close()
165 | 
166 |         t = Transaction(doc, "Check level " + e.Name)
167 |         t.Start()
168 |         elements = doc.Delete(e.Id)
169 |         t.RollBack()
170 | 
171 |         results[e.Name] = group_by_type(elements)
172 | 
173 |     return results
174 | 
175 | def selection_dependent():
176 |     """By selection"""
177 |     sel = selection.elements
178 |     
179 |     if not len(sel):
180 |         alert("Nothing selected")
181 |         return
182 | 
183 |     results = {}
184 |     for e in sel:
185 |         t = Transaction(doc, "Check selection " + str(e.Id.IntegerValue))
186 |         t.Start()
187 |         deleted_ids = doc.Delete(e.Id)
188 |         t.RollBack()
189 |         try:
190 |             el_type = e.Category.Name
191 |         except:
192 |             el_type = "Other"
193 |         # Exclude selected element from result
194 |         deleted_ids = filter(lambda x: x != e.Id, deleted_ids)
195 |         try:
196 |             name = e.Name
197 |         except:
198 |             name = "None"
199 |         results["%s, ID: %d, Name: %s" % (el_type, e.Id.IntegerValue, name)] = group_by_type(deleted_ids)
200 | 
201 |     return results
202 | 
203 | def workset_dependent():
204 |     """By workset"""
205 | 
206 |     selected_worksets = select_levels_dialog(all_worksets())
207 |     if not selected_worksets:
208 |         print("Nothing selected")
209 |         return
210 | 
211 |     results = {}
212 | 
213 |     for ws in selected_worksets:
214 |         elementCollector = FilteredElementCollector(doc)
215 |         elementWorksetFilter = ElementWorksetFilter(ws.Id, False)
216 |         element_ids = elementCollector.WherePasses(elementWorksetFilter).ToElementIds()
217 | 
218 |         results[ws.Name] = group_by_type(element_ids)
219 | 
220 |     return results
221 | 
222 | 
223 | def print_elements_for_parent(result_dict, parent_name):
224 |     """
225 |     Print dictionary as list of clickable elements ids grouped by type, etc
226 | 
227 | 
228 |     :param result_dict: {parent: {type: [element_ids]} }
229 |     :param parent_name:
230 |     """
231 | 
232 |     limit = config_limit()
233 | 
234 |     print(parent_name)
235 | 
236 |     e_ids = set()
237 |     limited_count = 0
238 | 
239 |     # show types : count only
240 |     if limit == 0:
241 |         counts =  dict(map(lambda (k, v): (k, len(v)), result_dict.iteritems()))
242 |         counts_sorted = sorted(counts.items(), key=operator.itemgetter(1), reverse=True)
243 |         for key, count in counts_sorted:
244 |             print('{}: {}'.format(key, count))
245 | 
246 |     # show types : elements ids
247 |     else:
248 |         ids_limited = []
249 |         for key, ids in result_dict.items():
250 |             print('{} - {}:'.format( key, output.linkify(ids, title=len(ids) ) ) )
251 | 
252 |             e_ids |= set(ids)
253 |             ids_limited = ids[:limit]
254 | 
255 |             limited_suffix = ""
256 |             if len(ids_limited) != len(ids):
257 |                 limited_delta = len(ids) - len(ids_limited)
258 |                 limited_suffix = " +%d..." % (limited_delta)
259 | 
260 |                 limited_count += limited_delta
261 | 
262 |             print(','.join(
263 |                 map(lambda x: output.linkify(x), ids_limited)
264 |             ) + limited_suffix)
265 | 
266 |             print('\n\n')
267 |                 
268 |         if len(e_ids) > 0:
269 |             print('{}'.format(output.linkify(list(e_ids), title='%d elements on %s' % (len(e_ids), parent_name))))
270 |         else:
271 |             print('%d elements on %s' % (len(e_ids), parent_name))
272 | 
273 |     print("\n\n\n")
274 | 
275 | 
276 | def print_elements(data):
277 |     for parent_name, result_dict in data.items():
278 |         print_elements_for_parent(result_dict, parent_name)
279 | 
280 | 
281 | def method_switch():
282 |     available_methods = [
283 |         level_dependent,
284 |         selection_dependent
285 |     ]
286 |     if doc.IsWorkshared:
287 |         available_methods.append(workset_dependent)
288 | 
289 |     available_methods_dict = dict(
290 |         (f.__doc__.split("\n")[0], f)
291 |         for f in available_methods
292 |     )
293 |     selected_switch = CommandSwitchWindow.show(available_methods_dict.keys(),
294 |                                                    message='Select method')
295 |     return available_methods_dict.get(selected_switch)
296 | 
297 | 
298 | def main():
299 |     func = method_switch()
300 |     if not func:
301 |         return
302 |     data = func()
303 |     if not data:
304 |         return
305 |     print_elements(data)
306 | 
307 | 
308 | if __name__ == '__main__':
309 |     main()
310 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils2.stack/SumParameter.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __title__ = 'Add/subtract param.'
  3 | __doc__ = """Takes value from one parameter and add (or subtract) it from another parameter.
  4 | 
  5 | Usage:
  6 | 1. Select elements which you want to process
  7 | 2. Run the script.
  8 | 3. Choose necessary parameters and options in a window
  9 | """
 10 | from Autodesk.Revit.UI import TaskDialog, TaskDialogCommonButtons
 11 | from Autodesk.Revit.DB import BuiltInCategory, ElementId, Definition, StorageType,Transaction, TransactionGroup
 12 | 
 13 | from pyrevit import script
 14 | from pyrevit.forms import WPFWindow, SelectFromList
 15 | 
 16 | logger = script.get_logger()
 17 | from pyrevit.revit import doc, selection
 18 | 
 19 | selection = selection.get_selection()
 20 | my_config = script.get_config()
 21 | 
 22 | ignore_types = [StorageType.ElementId, StorageType.None, StorageType.String]
 23 | 
 24 | OPERATIONS = {
 25 |     "__sub__": "Subtract from",
 26 |     "__add__": "Add to"
 27 | }
 28 | class CheckBoxParameter:
 29 |     def __init__(self, parameter, default_state=False):
 30 |         self.parameter = parameter
 31 |         self.name = parameter.Definition.Name
 32 |         self.state = default_state
 33 | 
 34 |     def __str__(self):
 35 |         return self.name
 36 | 
 37 |     def __nonzero__(self):
 38 |         return self.state
 39 | 
 40 |     def __bool__(self):
 41 |         return self.state
 42 | 
 43 | 
 44 | class CopyParameterWindow(WPFWindow):
 45 |     def __init__(self, xaml_file_name, selected_elements):
 46 |         self.selection = selected_elements
 47 |         if not self.selection:
 48 |             TaskDialog.Show(__title__, "Selection is empty")
 49 |             return
 50 | 
 51 |         self.parameters_dict = self.get_selection_parameters_numerical(self.selection)
 52 |         self.parameters_editable = self.filter_editable_numerical(self.parameters_dict)
 53 |         WPFWindow.__init__(self, xaml_file_name)
 54 |         self._set_comboboxes()
 55 |         self.read_config()
 56 | 
 57 |     def read_config(self):
 58 |         # check are last parameters available
 59 |         try:
 60 |             if my_config.parameter_to_get not in self.parameters:
 61 |                 my_config.parameter_to_get = ""
 62 |         except:
 63 |             pass
 64 |         try:
 65 |             if my_config.parameter_to_set not in self.parameters_editable:
 66 |                 my_config.parameter_to_set = ""
 67 |         except:
 68 |             pass
 69 | 
 70 |         try:
 71 |             self.parameterToGet.Text = str(my_config.parameter_to_get)
 72 |         except:
 73 |             self.parameterToGet.Text = my_config.parameter_to_get = ""
 74 | 
 75 |         try:
 76 |             self.parameterToSet.Text = str(my_config.parameter_to_set)
 77 |         except:
 78 |             self.parameterToSet.Text = my_config.parameter_to_set = ""
 79 | 
 80 |         try:
 81 |             self.resetToZero.IsChecked = my_config.reset_to_zero
 82 |         except:
 83 |             self.resetToZero.IsChecked = my_config.reset_to_zero = False
 84 | 
 85 |         try:
 86 |             self.operation.Text = str(my_config.operation)
 87 |         except:
 88 |             self.operation.Text = my_config.operation = OPERATIONS["__add__"]
 89 | 
 90 |     def write_config(self):
 91 |         my_config.parameter_to_get = self.parameterToGet.Text.encode('utf-8')
 92 |         my_config.parameter_to_set = self.parameterToSet.Text.encode('utf-8')
 93 |         my_config.operation = self.operation.Text.encode('utf-8')
 94 |         my_config.reset_to_zero = self.resetToZero.IsChecked
 95 |         script.save_config()
 96 | 
 97 |     def _set_comboboxes(self):
 98 |         self.parameterToGet.ItemsSource = sorted(self.parameters_dict.keys())
 99 |         self.parameterToSet.ItemsSource = sorted(self.parameters_editable.keys())
100 |         self.operation.ItemsSource = sorted(OPERATIONS.values())
101 | 
102 |     @property
103 |     def parameter_to_get(self):
104 |         p = self.parameters_dict[self.parameterToGet.Text]
105 |         return p
106 | 
107 |     @property
108 |     def parameter_to_set(self):
109 |         p = self.parameters_editable[self.parameterToSet.Text]
110 |         return p
111 | 
112 |     @property
113 |     def selected_operation(self):
114 |         for k, v in OPERATIONS.items():
115 |             if v == self.operation.Text:
116 |                 return k
117 | 
118 |     def process_operation(self, value_current, value_to_add):
119 |         operation_name = self.selected_operation
120 |         return getattr(value_current, operation_name)(value_to_add)
121 | 
122 |     def parameter_value_get(self, parameter):
123 |         if not parameter.HasValue:
124 |             return
125 | 
126 |         if parameter.StorageType == StorageType.Double:
127 |             x = parameter.AsDouble()
128 |         elif parameter.StorageType == StorageType.Integer:
129 |             x = int(parameter.AsInteger())
130 |         else:
131 |             x = None
132 |         return x
133 | 
134 |     def parameter_value_set(self, parameter, parameter_get):
135 |         if parameter_get.StorageType != parameter.StorageType:
136 |             return False
137 |         else:
138 |             value = self.parameter_value_get(parameter_get)
139 |         value_current = self.parameter_value_get(parameter)
140 |         parameter.Set(self.process_operation(value_current,value))
141 |         if self.resetToZero.IsChecked:
142 |             try:
143 |                 parameter_get.Set(0)
144 |             except Exception as exc:
145 |                 logger.error("Unable to set parameter to Zero, skipped:\n" + str(exc))
146 |         return True
147 | 
148 |     def run(self, sender, args):
149 |         count_changed = 0
150 | 
151 |         # find not empty parameter
152 |         definition_set = self.parameter_to_set.Definition
153 |         definition_get = self.parameter_to_get.Definition
154 |         not_empty_list = []
155 |         skip_ids = []
156 |         for e in self.selection:
157 |             param = e.get_Parameter(definition_set)
158 |             param_get = e.get_Parameter(definition_get)
159 |             if param.AsString() != '' and param.AsString() != None and param.AsString() != param_get.AsString():
160 |                 not_empty_list.append("Target: %s, Source: %s" % (self.parameter_value_get(param), self.parameter_value_get(param_get)))
161 | 
162 |                 skip_ids.append(e.Id)
163 | 
164 |         if len(not_empty_list) > 0:
165 |             len_limit = 10
166 |             len_not_empty_list = len(not_empty_list)
167 |             if len_not_empty_list > len_limit:
168 |                 not_empty_list = not_empty_list[:len_limit] + [' + %d more...' % (len_not_empty_list - len_limit)]
169 | 
170 |             text = "%d elements have values already. Replace them?\n" % len_not_empty_list + "\n".join(not_empty_list)
171 |             a = TaskDialog.Show(__title__, text,
172 |                                 TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No)
173 |             if str(a) == "Yes":
174 |                 skip_ids = []
175 | 
176 |         t = Transaction(doc, __title__)
177 |         t.Start()
178 | 
179 |         for e in self.selection:
180 |             if e.Id in skip_ids:
181 |                 continue
182 | 
183 |             param = e.get_Parameter(definition_set)
184 |             param_get = e.get_Parameter(definition_get)
185 | 
186 |             result = self.parameter_value_set(param, param_get)
187 |             if result:
188 |                 count_changed += 1
189 |             else:
190 |                 logger.error("Cannot sum different types")
191 |                 script.exit()
192 | 
193 |         self.write_config()
194 | 
195 |         if count_changed:
196 |             t.Commit()
197 |             TaskDialog.Show(__title__, "%d of %d elements updated" % (count_changed, len(self.selection),))
198 |         else:
199 |             t.RollBack()
200 |             TaskDialog.Show(__title__, "Nothing was changed")
201 | 
202 |     def element_parameter_dict(self, elements, parameter_to_sort):
203 |         result = {}
204 |         for e in elements:
205 |             param = e.get_Parameter(parameter_to_sort.Definition)
206 |             v = self.parameter_value_get(param)
207 |             if v:
208 |                 result[e] = v
209 | 
210 |         return result
211 | 
212 |     def get_selection_parameters_numerical(self, elements):
213 |         """
214 |         Get parameters which are common for all selected elements
215 | 
216 |         :param elements: Elements list
217 |         :return: dict - {parameter_name: Parameter}
218 |         """
219 |         result = {}
220 |         all_parameter_set = set()
221 |         all_parameter_ids_by_element = {}
222 | 
223 |         # find all ids
224 |         for e in elements:
225 |             for p in e.Parameters:
226 |                 p_id = p.Definition.Id
227 |                 if p.StorageType in ignore_types:
228 |                     continue
229 |                 all_parameter_set.add(p)
230 | 
231 |                 if e.Id not in all_parameter_ids_by_element.keys():
232 |                     all_parameter_ids_by_element[e.Id] = set()
233 |                 all_parameter_ids_by_element[e.Id].add(p_id)
234 | 
235 |         # filter
236 |         for p in all_parameter_set:
237 |             p_id = p.Definition.Id
238 |             exists_for_all_elements = True
239 |             for e_id, e_params in all_parameter_ids_by_element.items():
240 |                 if p_id not in e_params:
241 |                     exists_for_all_elements = False
242 |                     break
243 | 
244 |             if exists_for_all_elements:
245 |                 result[p.Definition.Name] = p
246 | 
247 |         return result
248 | 
249 |     def filter_editable_numerical(self, parameters):
250 |         """
251 |         Filter parameters which can be modified by users
252 | 
253 |         :param parameters: list of parameters
254 |         :return: filtered list of parameters
255 |         """
256 |         result = {n: p for n, p in parameters.iteritems()
257 |                   if not p.IsReadOnly
258 |                   and p.StorageType not in ignore_types}
259 |         return result
260 | 
261 |     def select_parameters(self):
262 |         parameters_dict = self.get_selection_parameters_numerical(self.selection)
263 |         parameters_editable = self.filter_editable_numerical(parameters_dict)
264 | 
265 |         options = []
266 |         for param_id, param in parameters_editable.items():
267 |             cb = CheckBoxParameter(param)
268 |             options.append(cb)
269 | 
270 |         selected = SelectFromList.show(options, title='Parameter to replace', width=300,
271 |                                        button_name='OK')
272 | 
273 |         return selected
274 | 
275 | 
276 | def main():
277 |     # Input
278 |     sel = selection.elements
279 |     CopyParameterWindow('window.xaml', sel).ShowDialog()
280 | 
281 | 
282 | if __name__ == "__main__":
283 |     main()
284 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils2.stack/CopyParameter.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __title__ = 'Copy parameter'
  3 | __doc__ = """Set value of one parameter to another one. Works with selected element or elements.
  4 | 
  5 | Shift-Click: change parameters by name
  6 | 
  7 | Записывает значение одного параметра в другой параметр выбранного элемента(ов)."""
  8 | 
  9 | __helpurl__ = "https://apex-project.github.io/pyApex/help#copy-paramter"
 10 | __context__ = 'Selection'
 11 | USE_NAMES = __shiftclick__
 12 | 
 13 | from pyrevit import script, revit, DB
 14 | from pyrevit.forms import WPFWindow, SelectFromList
 15 | from Autodesk.Revit.UI import TaskDialog, TaskDialogCommonButtons, TaskDialogResult
 16 | import pyapex_parameters as pyap
 17 | import pyapex_utils
 18 | 
 19 | selection = revit.selection.get_selection()
 20 | my_config = script.get_config()
 21 | logger = script.get_logger()
 22 | 
 23 | doc = revit.doc
 24 | 
 25 | 
 26 | class CheckBoxParameter:
 27 |     def __init__(self, parameter, default_state=False):
 28 |         self.parameter = parameter
 29 |         self.name = parameter.Definition.Name
 30 |         self.state = default_state
 31 | 
 32 |     def __str__(self):
 33 |         return self.name
 34 | 
 35 |     def __nonzero__(self):
 36 |         return self.state
 37 | 
 38 |     def __bool__(self):
 39 |         return self.state
 40 | 
 41 | 
 42 | class CopyParameterWindow(WPFWindow):
 43 |     def __init__(self, xaml_file_name, selected_elements):
 44 |         self.selection = selected_elements
 45 |         if not self.selection:
 46 |             TaskDialog.Show(__title__, "Selection is empty")
 47 |             return
 48 | 
 49 |         self.parameters_dict = pyap.get_selection_parameters(
 50 |             self.selection,
 51 |             attributes=False,
 52 |             check_on_all_elements=not USE_NAMES,
 53 |             mlogger=logger)
 54 |         self.parameters_editable = pyap.filter_editable(
 55 |             self.selection,
 56 |             self.parameters_dict,
 57 |             override_attrs=False,
 58 |             mlogger=logger)
 59 |         WPFWindow.__init__(self, xaml_file_name)
 60 |         self._set_comboboxes()
 61 |         self.read_config()
 62 | 
 63 |     def read_config(self):
 64 |         # check are last parameters available
 65 |         try:
 66 |             if my_config.parameter_to_get not in self.parameters_dict.keys():
 67 |                 my_config.parameter_to_get = ""
 68 |         except:
 69 |             pass
 70 |         try:
 71 |             if my_config.parameter_to_set not in self.parameters_editable.keys():
 72 |                 my_config.parameter_to_set = ""
 73 |         except:
 74 |             pass
 75 | 
 76 |         try:
 77 |             self.parameterToGet.Text = str(my_config.parameter_to_get)
 78 |         except:
 79 |             self.parameterToGet.Text = my_config.parameter_to_get = ""
 80 | 
 81 |         try:
 82 |             self.parameterToSet.Text = str(my_config.parameter_to_set)
 83 |         except:
 84 |             self.parameterToSet.Text = my_config.parameter_to_set = ""
 85 | 
 86 |     def write_config(self):
 87 |         my_config.parameter_to_get = self.parameterToGet.Text.encode('utf-8')
 88 |         my_config.parameter_to_set = self.parameterToSet.Text.encode('utf-8')
 89 |         script.save_config()
 90 | 
 91 |     def _set_comboboxes(self):
 92 |         self.parameterToGet.ItemsSource = sorted(self.parameters_dict.keys())
 93 |         self.parameterToSet.ItemsSource = sorted(self.parameters_editable.keys())
 94 | 
 95 |     @property
 96 |     def parameter_to_get(self):
 97 |         p = self.parameters_dict[self.parameterToGet.Text]
 98 |         return p
 99 | 
100 |     @property
101 |     def parameter_to_set(self):
102 |         p = self.parameters_editable[self.parameterToSet.Text]
103 |         return p
104 | 
105 |     def run(self, sender, args):
106 |         try:
107 | 
108 |             count_changed = 0
109 |             # find not empty parameter
110 |             def_or_name_set = pyap.definition_or_name(
111 |                 self.parameter_to_set
112 |             )
113 |             def_or_name_get = pyap.definition_or_name(
114 |                 self.parameter_to_get
115 |             )
116 | 
117 |             # collect ones to be updated - parameters_get which aren't empty and aren't equal
118 |             not_empty_list = []
119 |             skip_ids = []
120 |             errors_list_ids = []
121 |             errors_list = []
122 |             errors_text = ""
123 |             for e in self.selection:
124 |                 # todo clean up!
125 |                 if USE_NAMES or \
126 |                         (isinstance(def_or_name_get, DB.InternalDefinition) and
127 |                                 not def_or_name_get.BuiltInParameter) or \
128 |                         (isinstance(def_or_name_get, DB.ExternalDefinition) and
129 |                           not def_or_name_get.GUID):
130 |                     param_get = e.LookupParameter(def_or_name_get.Name)
131 |                 else:
132 |                     if isinstance(def_or_name_get, DB.InternalDefinition):
133 |                         param_get = e.get_Parameter(def_or_name_get.BuiltInParameter)
134 |                     else:
135 |                         param_get = e.get_Parameter(def_or_name_get.GUID)
136 | 
137 |                 if USE_NAMES or \
138 |                         (isinstance(def_or_name_set, DB.InternalDefinition) and
139 |                                 not def_or_name_set.BuiltInParameter) or \
140 |                         (isinstance(def_or_name_set, DB.ExternalDefinition) and
141 |                           not def_or_name_set.GUID):
142 |                     param = e.LookupParameter(def_or_name_set.Name)
143 |                 else:
144 |                     if isinstance(def_or_name_set, DB.InternalDefinition):
145 |                         param = e.get_Parameter(def_or_name_set.BuiltInParameter)
146 |                     else:
147 |                         param = e.get_Parameter(def_or_name_set.GUID)
148 | 
149 | 
150 |                 if not param or not param_get:
151 |                     logger.debug("One of parameters not found for e.Id:%d" % e.Id.IntegerValue)
152 |                     continue
153 |                 if pyap.is_empty(param):
154 |                     logger.debug("Empty Get for e.Id:%d" % e.Id.IntegerValue)
155 |                     continue
156 |                 if pyap.are_equal(param, param_get):
157 |                     logger.debug("Are Equal for e.Id:%d" % e.Id.IntegerValue)
158 |                     continue
159 |                 value_get, value_set = pyap.convert_value(param_get, param, return_both=True)
160 | 
161 |                 not_empty_list.append("Target: %s, Source: %s" % (value_set, value_get))
162 |                 skip_ids.append(e.Id)
163 | 
164 |             if len(not_empty_list) > 0:
165 |                 len_limit = 10
166 |                 len_not_empty_list = len(not_empty_list)
167 |                 if len_not_empty_list > len_limit:
168 |                     not_empty_list = not_empty_list[:len_limit] + [' + %d more...' % (len_not_empty_list - len_limit)]
169 | 
170 |                 text = "%d elements have values already. Replace them?\n" % len_not_empty_list + "\n".join(
171 |                     not_empty_list)
172 |                 a = TaskDialog.Show(__title__, text,
173 |                                     TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No)
174 |                 if a == TaskDialogResult.Yes:
175 |                     skip_ids = []
176 | 
177 |             t = DB.Transaction(doc, __title__)
178 |             t.Start()
179 |             for e in self.selection:
180 |                 if USE_NAMES:
181 |                     param = e.LookupParameter(def_or_name_set.Name)
182 |                     param_get = e.LookupParameter(def_or_name_get.Name)
183 |                     if not param or not param_get:
184 |                         logger.debug("One of parameters not found for e.Id:%d" % e.Id.IntegerValue)
185 |                         continue
186 |                 else:
187 |                     param = e.get_Parameter(def_or_name_set)
188 |                     param_get = e.get_Parameter(def_or_name_get)
189 |                 _definition_set = param.Definition
190 |                 _definition_get = param_get.Definition
191 | 
192 |                 if e.Id in skip_ids:
193 |                     continue
194 |                 try:
195 |                     if pyap.copy_parameter(e, _definition_get, _definition_set):
196 |                         count_changed += 1
197 |                 except Exception as exc:
198 |                     errors_list_ids.append(e.Id)
199 |                     errors_list.append("Id: %d, exception: %s" % (e.Id.IntegerValue, str(exc)))
200 |             if errors_list:
201 |                 errors_text = ("\n\nErrors occurred with %d elements :\n" % len(errors_list)) + \
202 |                               "\n".join(errors_list[:5])
203 |                 if len(errors_list) > 5:
204 |                     errors_text += "\n..."
205 |                 errors_text += "\n\nValues weren't changed, elements with errors selected"
206 |                 selection.set_to(errors_list_ids)
207 | 
208 |             if count_changed or errors_list:
209 |                 t.Commit()
210 |                 TaskDialog.Show(__title__,
211 |                                 "%d of %d elements updated%s" % (count_changed, len(self.selection), errors_text))
212 |             else:
213 |                 t.RollBack()
214 |                 TaskDialog.Show(__title__, "Nothing was changed")
215 |             logger.debug("finished")
216 |         except Exception as exc:
217 |             logger.error(exc)
218 | 
219 |         # TODO FIX do not write config in lower versions - risk to corrupt config
220 |         if (
221 |                 pyapex_utils.is_ascii(self.parameterToGet.Text) and
222 |                 pyapex_utils.is_ascii(self.parameterToSet.Text)):
223 |             try:
224 |                 self.write_config()
225 |             except:
226 |                 logger.warn("Cannot save config")
227 |         self.Close()
228 | 
229 |     def element_parameter_dict(self, elements, parameter_to_sort):
230 |         result = {}
231 |         for e in elements:
232 |             if type(parameter_to_sort) == str:
233 |                 if parameter_to_sort[0] == "<" and parameter_to_sort[2:] == " coordinate>":
234 |                     parameter_loc = parameter_to_sort[1]
235 |                     loc = e.Location
236 |                     v = getattr(loc.Point, parameter_loc)
237 |                 else:
238 |                     logger.error("Parameter error")
239 |                     return
240 |             else:
241 |                 param = e.get_Parameter(parameter_to_sort.Definition)
242 |                 v = pyap.parameter_value_get(param)
243 |             if v:
244 |                 result[e] = v
245 | 
246 |         return result
247 | 
248 | 
249 |     def parameter_key(self, parameter):
250 |         if USE_NAMES:
251 |             p_key = parameter.Definition.Name
252 |         else:
253 |             p_key = parameter.Definition.Id
254 |         return p_key
255 | 
256 | 
257 |     def select_parameters(self):
258 |         options = []
259 |         for param_id, param in self.parameters_editable.items():
260 |             cb = CheckBoxParameter(param)
261 |             options.append(cb)
262 | 
263 |         selected = SelectFromList.show(options, title='Parameter to replace', width=300,
264 |                                        button_name='OK')
265 | 
266 |         return selected
267 | 
268 | 
269 | def main():
270 |     # Input
271 |     sel = selection.elements
272 |     CopyParameterWindow('window.xaml', sel).ShowDialog()
273 | 
274 | 
275 | if __name__ == "__main__":
276 |     main()
277 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/Purge.pulldown/TagsDuplicates.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __title__ = 'Find duplicate\nTags'
  3 | __doc__ = """Select duplicated tags. If there are more than 2 tags for element on a view it will select redundant ones.
  4 | 
  5 | Shitf+Click - on all views
  6 | 
  7 | Выделяет повторяющиеся Марки-аннотации. Если на виде больше 2 марок для одного объекта, лишние будут выделены.
  8 | """
  9 | 
 10 | __helpurl__ = "https://apex-project.github.io/pyApex/help#find-duplicate-tags"
 11 | 
 12 | try:
 13 |     from pyrevit.versionmgr import PYREVIT_VERSION
 14 | except:
 15 |     from pyrevit import versionmgr
 16 |     PYREVIT_VERSION = versionmgr.get_pyrevit_version()
 17 | 
 18 | pyRevitNewer44 = PYREVIT_VERSION.major >=4 and PYREVIT_VERSION.minor >=5
 19 | 
 20 | 
 21 | if pyRevitNewer44:
 22 |     from pyrevit import script, revit
 23 |     from pyrevit.revit import uidoc, doc
 24 |     from pyrevit.forms import CommandSwitchWindow
 25 |     output = script.get_output()
 26 |     logger = script.get_logger()
 27 |     linkify = output.linkify
 28 |     selection = revit.get_selection()
 29 |     my_config = script.get_config()
 30 | 
 31 | else:
 32 |     from scriptutils import logger, this_script as script
 33 |     from revitutils import doc, selection, uidoc
 34 |     from scriptutils.userinput import CommandSwitchWindow
 35 |     output = script.output
 36 |     my_config = script.config
 37 | 
 38 | from Autodesk.Revit.DB import FilteredElementCollector, BuiltInCategory, ViewType, ElementId, AreaTag, FamilyInstance
 39 | from Autodesk.Revit.DB.Architecture import RoomTag
 40 | from Autodesk.Revit.UI import TaskDialog, TaskDialogCommonButtons
 41 | 
 42 | from System.Collections.Generic import List
 43 | 
 44 | # TODO think how to implement parent-parameter selection (tag.Door, tag.Room etc.)
 45 | switches = {
 46 |     "AreaLoadTags": BuiltInCategory.OST_AreaLoadTags,
 47 |     "AreaReinTags": BuiltInCategory.OST_AreaReinTags,
 48 |     "AreaTags": BuiltInCategory.OST_AreaTags,
 49 |     "BeamAnalyticalTags": BuiltInCategory.OST_BeamAnalyticalTags,
 50 |     "BeamSystemTags": BuiltInCategory.OST_BeamSystemTags,
 51 |     "BraceAnalyticalTags": BuiltInCategory.OST_BraceAnalyticalTags,
 52 |     "CableTrayFittingTags": BuiltInCategory.OST_CableTrayFittingTags,
 53 |     "CableTrayTags": BuiltInCategory.OST_CableTrayTags,
 54 |     "CaseworkTags": BuiltInCategory.OST_CaseworkTags,
 55 |     "CeilingTags": BuiltInCategory.OST_CeilingTags,
 56 |     "ColumnAnalyticalTags": BuiltInCategory.OST_ColumnAnalyticalTags,
 57 |     "CommunicationDeviceTags": BuiltInCategory.OST_CommunicationDeviceTags,
 58 |     "ConduitFittingTags": BuiltInCategory.OST_ConduitFittingTags,
 59 |     "ConduitTags": BuiltInCategory.OST_ConduitTags,
 60 |     "CouplerTags": BuiltInCategory.OST_CouplerTags,
 61 |     "CurtainWallPanelTags": BuiltInCategory.OST_CurtainWallPanelTags,
 62 |     "CurtaSystemTags": BuiltInCategory.OST_CurtaSystemTags,
 63 |     "DetailComponentTags": BuiltInCategory.OST_DetailComponentTags,
 64 |     "DoorTags": BuiltInCategory.OST_DoorTags,
 65 |     "DuctAccessoryTags": BuiltInCategory.OST_DuctAccessoryTags,
 66 |     "DuctFittingTags": BuiltInCategory.OST_DuctFittingTags,
 67 |     "DuctInsulationsTags": BuiltInCategory.OST_DuctInsulationsTags,
 68 |     "DuctLiningsTags": BuiltInCategory.OST_DuctLiningsTags,
 69 |     "DuctTags": BuiltInCategory.OST_DuctTags,
 70 |     "DuctTerminalTags": BuiltInCategory.OST_DuctTerminalTags,
 71 |     "ElectricalCircuitTags": BuiltInCategory.OST_ElectricalCircuitTags,
 72 |     "ElectricalEquipmentTags": BuiltInCategory.OST_ElectricalEquipmentTags,
 73 |     "ElectricalFixtureTags": BuiltInCategory.OST_ElectricalFixtureTags,
 74 |     "FabricAreaTags": BuiltInCategory.OST_FabricAreaTags,
 75 |     "FabricationContainmentTags": BuiltInCategory.OST_FabricationContainmentTags,
 76 |     "FabricationDuctworkTags": BuiltInCategory.OST_FabricationDuctworkTags,
 77 |     "FabricationHangerTags": BuiltInCategory.OST_FabricationHangerTags,
 78 |     "FabricationPipeworkTags": BuiltInCategory.OST_FabricationPipeworkTags,
 79 |     "FabricReinforcementTags": BuiltInCategory.OST_FabricReinforcementTags,
 80 |     "FireAlarmDeviceTags": BuiltInCategory.OST_FireAlarmDeviceTags,
 81 |     "FlexDuctTags": BuiltInCategory.OST_FlexDuctTags,
 82 |     "FlexPipeTags": BuiltInCategory.OST_FlexPipeTags,
 83 |     "FloorAnalyticalTags": BuiltInCategory.OST_FloorAnalyticalTags,
 84 |     "FloorTags": BuiltInCategory.OST_FloorTags,
 85 |     "FootingSpanDirectionSymbol": BuiltInCategory.OST_FootingSpanDirectionSymbol,
 86 |     "FoundationSlabAnalyticalTags": BuiltInCategory.OST_FoundationSlabAnalyticalTags,
 87 |     "FurnitureSystemTags": BuiltInCategory.OST_FurnitureSystemTags,
 88 |     "FurnitureTags": BuiltInCategory.OST_FurnitureTags,
 89 |     "GenericModelTags": BuiltInCategory.OST_GenericModelTags,
 90 |     "HostFinTags": BuiltInCategory.OST_HostFinTags,
 91 |     "InternalAreaLoadTags": BuiltInCategory.OST_InternalAreaLoadTags,
 92 |     "InternalLineLoadTags": BuiltInCategory.OST_InternalLineLoadTags,
 93 |     "InternalPointLoadTags": BuiltInCategory.OST_InternalPointLoadTags,
 94 |     "IsolatedFoundationAnalyticalTags": BuiltInCategory.OST_IsolatedFoundationAnalyticalTags,
 95 |     "KeynoteTags": BuiltInCategory.OST_KeynoteTags,
 96 |     "LightingDeviceTags": BuiltInCategory.OST_LightingDeviceTags,
 97 |     "LightingFixtureTags": BuiltInCategory.OST_LightingFixtureTags,
 98 |     "LineLoadTags": BuiltInCategory.OST_LineLoadTags,
 99 |     "LinkAnalyticalTags": BuiltInCategory.OST_LinkAnalyticalTags,
100 |     "MassAreaFaceTags": BuiltInCategory.OST_MassAreaFaceTags,
101 |     "MassTags": BuiltInCategory.OST_MassTags,
102 |     "MaterialTags": BuiltInCategory.OST_MaterialTags,
103 |     "MechanicalEquipmentTags": BuiltInCategory.OST_MechanicalEquipmentTags,
104 |     "MEPSpaceTags": BuiltInCategory.OST_MEPSpaceTags,
105 |     "MultiCategoryTags": BuiltInCategory.OST_MultiCategoryTags,
106 |     "NodeAnalyticalTags": BuiltInCategory.OST_NodeAnalyticalTags,
107 |     "NurseCallDeviceTags": BuiltInCategory.OST_NurseCallDeviceTags,
108 |     "ParkingTags": BuiltInCategory.OST_ParkingTags,
109 |     "PathReinTags": BuiltInCategory.OST_PathReinTags,
110 |     "PipeAccessoryTags": BuiltInCategory.OST_PipeAccessoryTags,
111 |     "PipeFittingTags": BuiltInCategory.OST_PipeFittingTags,
112 |     "PipeInsulationsTags": BuiltInCategory.OST_PipeInsulationsTags,
113 |     "PipeTags": BuiltInCategory.OST_PipeTags,
114 |     "PlantingTags": BuiltInCategory.OST_PlantingTags,
115 |     "PlumbingFixtureTags": BuiltInCategory.OST_PlumbingFixtureTags,
116 |     "PointLoadTags": BuiltInCategory.OST_PointLoadTags,
117 |     "RailingSystemTags": BuiltInCategory.OST_RailingSystemTags,
118 |     "RebarTags": BuiltInCategory.OST_RebarTags,
119 |     "RevisionCloudTags": BuiltInCategory.OST_RevisionCloudTags,
120 |     "RoomTags": BuiltInCategory.OST_RoomTags,
121 |     "SecurityDeviceTags": BuiltInCategory.OST_SecurityDeviceTags,
122 |     "SitePropertyLineSegmentTags": BuiltInCategory.OST_SitePropertyLineSegmentTags,
123 |     "SitePropertyTags": BuiltInCategory.OST_SitePropertyTags,
124 |     "SiteTags": BuiltInCategory.OST_SiteTags,
125 |     "SpanDirectionSymbol": BuiltInCategory.OST_SpanDirectionSymbol,
126 |     "SpecialityEquipmentTags": BuiltInCategory.OST_SpecialityEquipmentTags,
127 |     "SpotCoordinateSymbols": BuiltInCategory.OST_SpotCoordinateSymbols,
128 |     "SpotElevSymbols": BuiltInCategory.OST_SpotElevSymbols,
129 |     "SpotSlopesSymbols": BuiltInCategory.OST_SpotSlopesSymbols,
130 |     "SprinklerTags": BuiltInCategory.OST_SprinklerTags,
131 |     "StairsLandingTags": BuiltInCategory.OST_StairsLandingTags,
132 |     "StairsRunTags": BuiltInCategory.OST_StairsRunTags,
133 |     "StairsSupportTags": BuiltInCategory.OST_StairsSupportTags,
134 |     "StairsTags": BuiltInCategory.OST_StairsTags,
135 |     "StairsTriserTags": BuiltInCategory.OST_StairsTriserTags,
136 |     "StructConnectionTags": BuiltInCategory.OST_StructConnectionTags,
137 |     "StructuralColumnTags": BuiltInCategory.OST_StructuralColumnTags,
138 |     "StructuralConnectionHandlerTags_Deprecated": BuiltInCategory.OST_StructuralConnectionHandlerTags_Deprecated,
139 |     "StructuralFoundationTags": BuiltInCategory.OST_StructuralFoundationTags,
140 |     "StructuralFramingTags": BuiltInCategory.OST_StructuralFramingTags,
141 |     "TelephoneDeviceTags": BuiltInCategory.OST_TelephoneDeviceTags,
142 |     "TrussTags": BuiltInCategory.OST_TrussTags,
143 |     "WallAnalyticalTags": BuiltInCategory.OST_WallAnalyticalTags,
144 |     "WallFoundationAnalyticalTags": BuiltInCategory.OST_WallFoundationAnalyticalTags,
145 |     "WallTags": BuiltInCategory.OST_WallTags,
146 |     "WindowTags": BuiltInCategory.OST_WindowTags,
147 |     "WireTags": BuiltInCategory.OST_WireTags,
148 | }
149 | 
150 | 
151 | def find_duplicates_on_view(tags, view_name):
152 |     tags_dict = {}
153 | 
154 |     linked_found = 0
155 | 
156 |     for tag in tags:
157 |         # try:
158 |         #     # TODO find the way to check tags connected to linked file
159 |         if type(tag) == FamilyInstance:
160 |             continue
161 |         elif type(tag) == RoomTag:
162 |             k = tag.Room.Id
163 |         elif type(tag) == AreaTag:
164 |             k = tag.Area.Id
165 |         else:
166 |             k = tag.TaggedLocalElementId
167 | 
168 |         # except:
169 |         #     continue
170 | 
171 |         if k.IntegerValue == -1:
172 |             linked_found += 1
173 |             continue
174 | 
175 |         if k not in tags_dict:
176 |             tags_dict[k] = []
177 | 
178 |         tags_dict[k].append(tag.Id)
179 |         # except:
180 |         #     logger.info(str(tag.Id) + " unknown exception")
181 | 
182 |     duplicates_id = []
183 | 
184 |     for t in tags_dict.keys():
185 |         if len(tags_dict[t]) > 1:
186 |             tags_sorted = sorted(tags_dict[t], key = lambda x: x.IntegerValue)
187 |             # append all ids except the first
188 |             duplicates_id += list(tags_sorted)[1:]
189 | 
190 |     if linked_found:
191 |         logger.warning("View %s has %d tags connected to linked model. They can't be checked" % (
192 |             view_name, linked_found
193 |         ))
194 |     return duplicates_id
195 | 
196 | 
197 | def select_duplicate_tags(tags_by_view, selected_switch, all_views):
198 |     duplicates_id = []
199 |     for view, tags in tags_by_view.items():
200 |         view_name = doc.GetElement(view).Name
201 | 
202 |         duplicates_id_view = find_duplicates_on_view(tags, view_name)
203 |         duplicates_id += duplicates_id_view
204 |         dup_count = len(duplicates_id_view)
205 |         if all_views and dup_count > 0:
206 |             print("View \"%s\": %d of %d tags duplicated" % (
207 |                 view_name, dup_count, len(tags) )
208 |                   )
209 | 
210 |     if pyRevitNewer44:
211 |         selection.set_to(duplicates_id)
212 |     else:
213 |         collection = List[ElementId](duplicates_id)
214 |         selection.SetElementIds(collection)
215 | 
216 |     if len(duplicates_id)>0:
217 |         print("%d duplicated %s selected" % (len(duplicates_id), selected_switch))
218 |     else:
219 |         print("No duplicated %s found" % (len(duplicates_id), selected_switch))
220 | 
221 | 
222 | def get_tags_by_type(all_views):
223 |     # find available tags in project
224 |     tags_by_type = {}
225 | 
226 |     for cat_name, cat in switches.items():
227 |         cl_tags = FilteredElementCollector(doc)
228 |         tags = cl_tags.OfCategory(cat)
229 | 
230 |         # Find only current view tags, if not ShiftClick
231 |         if not all_views:
232 |             tags = tags.OwnedByView(doc.ActiveView.Id)
233 | 
234 |         tags = tags.WhereElementIsNotElementType().ToElements()
235 | 
236 |         tags = filter(lambda t: type(t) != FamilyInstance, tags)
237 | 
238 |         if len(tags) == 0:
239 |             continue
240 |         else:
241 |             logger.debug("%d %s found" % (len(tags), cat_name))
242 | 
243 |             tags_by_view = {}
244 | 
245 |             for e in tags:
246 |                 v = e.OwnerViewId
247 |                 if not v:
248 |                     continue
249 | 
250 |                 if v not in tags_by_view.keys():
251 |                     tags_by_view[v] = []
252 |                 tags_by_view[v].append(e)
253 | 
254 |             tags_by_type[cat_name] = tags_by_view
255 | 
256 |     return tags_by_type
257 | 
258 | 
259 | def main(all_views = __shiftclick__):
260 | 
261 |     # fetching all tags in a project
262 |     tags_by_type = get_tags_by_type(all_views)
263 |     available_types = tags_by_type.keys()
264 | 
265 |     if len(available_types) == 0:
266 |         text_pre = 'No tags were found '
267 |         if all_views:
268 |             text = text_pre + 'in a project'
269 |             TaskDialog.Show(__title__, text)
270 |         else:
271 |             text = text_pre + 'on active view.\nLet\'s try to find tags on all other views?'
272 |             res = TaskDialog.Show(__title__, text,
273 |                                   TaskDialogCommonButtons.Yes |
274 |                                   TaskDialogCommonButtons.No)
275 | 
276 |             if str(res) == "Yes":
277 |                 main(all_views=True)
278 | 
279 |         return
280 | 
281 |     selected_switch = CommandSwitchWindow.show(available_types,
282 |                                                message='Select tag type')
283 |     if selected_switch:
284 |         tags_by_view = tags_by_type[selected_switch]
285 |         select_duplicate_tags(tags_by_view, selected_switch, all_views)
286 | 
287 | 
288 | if __name__ == '__main__':
289 |     main()
290 | 


--------------------------------------------------------------------------------
/pyApex.tab/QualityControl.panel/GridDistance.pushbutton/GridDistance_script.py:
--------------------------------------------------------------------------------
  1 | __title__ = "Grid Distance"
  2 | from pyrevit import script, revit
  3 | 
  4 | logger = script.get_logger()
  5 | output = script.get_output()
  6 | linkify = output.linkify
  7 | selection = revit.get_selection()
  8 | doc = revit.doc
  9 | uidoc = revit.uidoc
 10 | 
 11 | import clr
 12 | import math
 13 | import itertools
 14 | from Autodesk.Revit.UI import TaskDialog, TaskDialogCommonButtons
 15 | from Autodesk.Revit.DB import *
 16 | # from typing import List, Dict, Tuple
 17 | 
 18 | def get_grids(view_id=None, ids=False):
 19 |     """
 20 |     Collect all grids in current document
 21 | 
 22 |     :param view_id: filter by view
 23 |     :param ids: return ids or elements
 24 |     :return: list of ids or elements
 25 |     """
 26 |     if view_id:
 27 |         cl = FilteredElementCollector(doc, view_id)
 28 |     else:
 29 |         cl = FilteredElementCollector(doc)
 30 |     grids = cl.OfCategory(BuiltInCategory.OST_Grids).WhereElementIsNotElementType()
 31 |     if ids:
 32 |         return grids.ToElementIds()
 33 |     else:
 34 |         return grids.ToElements()
 35 | 
 36 | 
 37 | def curve_location(crv, base_curve):  # type: (Line, Line) -> XYZ
 38 |     crv.MakeUnbound()
 39 |     intersection_result_array = clr.Reference[IntersectionResultArray]()
 40 |     set_comparison_result = base_curve.Intersect(crv, intersection_result_array)
 41 |     if set_comparison_result != SetComparisonResult.Overlap:
 42 |         raise Exception("set_comparison_result != SetComparisonResult.Overlap: %s" %
 43 |                         str(set_comparison_result))
 44 |     for intersection_result in intersection_result_array.GetEnumerator():
 45 |         print(intersection_result)
 46 |         return intersection_result.XYZPoint
 47 | 
 48 | 
 49 | def curve_angle(crv, mode="deg", precision_max=5):
 50 |     pt_start = crv.GetEndPoint(0)
 51 |     pt_end = crv.GetEndPoint(1)
 52 |     x = abs(pt_start.X - pt_end.X)
 53 |     y = abs(pt_start.Y - pt_end.Y)
 54 |     if x == 0:
 55 |         rad = 0
 56 |     else:
 57 |         rad = math.atan(y / x)
 58 |     k = 1
 59 |     if pt_start.X < pt_end.X:
 60 |         k *= -1
 61 |     if pt_start.Y < pt_end.Y:
 62 |         k *= -1
 63 |     rad = rad * k
 64 | 
 65 |     if mode == "deg":
 66 |         return round(math.degrees(rad) % 90, precision_max)
 67 |     else:
 68 |         return round(rad % (math.pi / 2), precision_max + 3)
 69 | 
 70 | 
 71 | def split_angles_list(list_of_angles, precision=2):
 72 |     """
 73 |     Generator to split list of angles by group with certain precision
 74 | 
 75 |     :param list_of_angles: list of angles to group
 76 |     :param precision: precision in degrees. If the difference is larger than this value, it would be considered as a new group
 77 |     :return: a Generator which yields each group of angles as separated list
 78 |     """
 79 |     out = []  # temporary "container" with angles in current group
 80 |     # sort angles in given list
 81 |     list_of_angles = list(list_of_angles)
 82 |     list_of_angles.sort()
 83 |     # set first value as minimum value
 84 |     last_min_angle = list_of_angles[0]
 85 |     # iterate through each angle in sorted list
 86 |     for x in list_of_angles:
 87 |         # get difference between two angles
 88 |         # if the difference is larger than precision (by default >2 degrees)
 89 |         # that means a new group has begun
 90 |         if abs(x - last_min_angle) > precision:
 91 |             # yield list of angles in current group
 92 |             yield out
 93 |             # and erase temporary "container"
 94 |             out = []
 95 |             last_min_angle = x
 96 |         # add angle to a temporary "container"
 97 |         out.append(x)
 98 |     if len(out) > 0:
 99 |         yield out
100 | 
101 | 
102 | curve_angles = {}
103 | curve_distances = {}
104 | 
105 | 
106 | def group_grids(grids, precision=2):
107 |     """
108 |     Group grids by angle
109 | 
110 |     :param grids: grids to group
111 |     :param curve_angles: dictionary of 
112 |     :param precision: precision (e.g. if 2 then 0.01 degrees difference would be considered as the same group
113 |     :return: {angle : [grids]}
114 |     """
115 |     global curve_angles
116 |     # FIXME check: there can be a failure, than many grids have the same angle.
117 |     #  It is not correct to group them by angle
118 |     #  But if they are already grouped that's okay ?
119 |     groups_by_angle_no_round = {}  # dictionary (angle : [grid]s)
120 |     groups_by_angle = {}  # each first angle in splited list [angle : [[grid]s]]
121 | 
122 |     for grid in grids:
123 |         grid_angle = curve_angle(grid.Curve)
124 |         curve_angles[grid.Id] = grid_angle
125 | 
126 |         if grid_angle not in groups_by_angle_no_round.keys():
127 |             groups_by_angle_no_round[grid_angle] = []
128 |         groups_by_angle_no_round[grid_angle].append(grid)
129 | 
130 |     grid_angles = list(groups_by_angle_no_round.keys())
131 | 
132 |     # split angles list with certain precision
133 |     for angles_group in split_angles_list(grid_angles, precision):
134 |         # check if first angle in a group already in a dictionary
135 |         # (first angle is a leader of the group)
136 |         if angles_group[0] not in groups_by_angle.keys():
137 |             groups_by_angle[angles_group[0]] = []
138 | 
139 |         for k in angles_group:
140 |             groups_by_angle[angles_group[0]] += groups_by_angle_no_round[k]
141 |     logger.debug("groups_by_angle:")
142 |     logger.debug(groups_by_angle)
143 |     return groups_by_angle
144 | 
145 | 
146 | def find_outlier_grids_distance(
147 |         grids_grouped):  # type: (Dict[float, List[Grid]]) -> List[Tuple[List[ElementId],List[ElementId]]]
148 |     """
149 |     Get list of outliers (and orphaned) in certain format. If there are no outliers, list won't be mentioned
150 |     :param grids_grouped: dictionary {angle: [grids]}
151 |     :return: [([ids_good],[ids_bad]),...]
152 |     """
153 |     global curve_angles
154 |     group_outliers = {}
155 | 
156 |     result = []
157 | 
158 |     for group_angle, group_grids in grids_grouped.items():
159 |         if group_angle not in group_outliers.keys():
160 |             group_outliers[group_angle] = {}
161 | 
162 |         # extend dictionary with grids by adding one more level
163 |         # was: {group_angle: [grids]}
164 |         # now: {group_angle: {grid_angle: grids}}
165 |         for grid in group_grids:
166 |             grid_angle = curve_angles[grid.Id]
167 |             if grid_angle not in group_outliers[group_angle].keys():
168 |                 group_outliers[group_angle][grid_angle] = []
169 |             group_outliers[group_angle][grid_angle].append(grid.Id)
170 |         # if all grids in a group have the same angle - that's okay, skip it
171 |         if len(group_outliers[group_angle].keys()) == 1:
172 |             continue
173 |         # Sort precise grid groups by length - how many grids in each of them
174 |         # only group angles (keys) are stored
175 |         angles_sorted = sorted(group_outliers[group_angle].keys(),
176 |                                key=lambda x: len(group_outliers[group_angle][x]),
177 |                                reverse=True)
178 |         ids_good = [] # type : List[ElementId]
179 |         ids_bad = [] # type : List[ElementId]
180 |         # iterate through angles of sub groups
181 |         for i in range(len(angles_sorted)):
182 |             grid = angles_sorted[i]
183 |             # put the largest sub group in GOOD results
184 |             if i == 0 and len(group_outliers[group_angle][grid]) > 1:
185 |                 ids_good += group_outliers[group_angle][grid]
186 |             # put all the others sub groups in BAD result
187 |             #  (as well as orphaned - groups with only one grids inside)
188 |             else:
189 |                 ids_bad += group_outliers[group_angle][grid]
190 |         result.append((ids_good, ids_bad))
191 |     return result
192 | 
193 | 
194 | def get_design_options_ids(doc):
195 |     """
196 |     Get design options in a document
197 | 
198 |     :param doc: Document
199 |     :return: dictionary of ids DesignOptionsSets and ids of DesignOptions
200 |     """
201 |     cl = FilteredElementCollector(doc)
202 | 
203 |     design_options = cl.OfClass(DesignOption).WhereElementIsNotElementType().ToElements()
204 |     if len(design_options) == 0:
205 |         return
206 | 
207 |     do_dict = {}
208 |     for do in design_options:
209 |         s_id = do.get_Parameter(BuiltInParameter.OPTION_SET_ID).AsElementId()
210 |         if s_id not in do_dict.keys():
211 |             do_dict[s_id] = []
212 |         do_dict[s_id].append(do.Id)
213 | 
214 |     return do_dict
215 | 
216 | 
217 | def element_design_option_equals(element, design_options_id):
218 |     """
219 |     Check if design option of certain element equals given design option
220 |     or has no design option
221 | 
222 |     :param element: Element to check
223 |     :param design_options_id: Design option id to compare
224 |     :return: bool
225 |     """
226 |     do = element.get_Parameter(BuiltInParameter.DESIGN_OPTION_ID).AsElementId()
227 |     return do == ElementId.InvalidElementId or do in design_options_id
228 | 
229 | 
230 | def group_by_design_options(elements, design_options_dict):
231 |     """
232 |     Group elements of design options
233 | 
234 |     :param elements: Elements to group
235 |     :param design_options_dict: Dictionary of DesignOptionSets and DesignOptions
236 |     :return:
237 |     """
238 |     combinations = list(itertools.product(*list(design_options_dict.values())))
239 |     result = []
240 |     for c in combinations:
241 |         els = filter(lambda e: element_design_option_equals(e, c), elements)
242 |         result.append(list(els))
243 |     return result
244 | 
245 | 
246 | def run(interactive=False):
247 |     """
248 | 
249 |     :param interactive: show dialogs
250 |     :return: None
251 |     """
252 | 
253 |     # Ask user to confirm running of the script
254 |     if interactive:
255 |         text = "Run Grid distance check?"
256 |         a = TaskDialog.Show(__title__, text,
257 |                             TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.Cancel)
258 |         if str(a) != "Yes":
259 |             return
260 |     # Collect all grids in current document
261 |     grids = get_grids()
262 |     # Filter linear grids
263 |     grids_linear = filter(lambda x: not x.IsCurved, grids)
264 |     # Get list of design options in a document
265 |     design_options_dict = get_design_options_ids(doc)
266 |     # If there are design options in a document, group grids
267 |     if design_options_dict:
268 |         # list of lists of elements grouped by design options
269 |         elements_by_design_option = group_by_design_options(grids_linear, design_options_dict)
270 |     else:
271 |         elements_by_design_option = [grids_linear, ]
272 |     ids_bad_to_override = []  # list of false result
273 |     ids_orphaned = []  # list of "outliers"
274 | 
275 |     for i in range(len(elements_by_design_option)):
276 |         # if there are design options in a document, show combination index
277 |         if len(elements_by_design_option) > 1:
278 |             print("Design options combination %d" % (i + 1))
279 |         # get list of grids in current design options combination
280 |         grids_by_design_option = elements_by_design_option[i]
281 |         logger.debug(grids_by_design_option)
282 | 
283 |         grids_grouped = group_grids(grids_by_design_option, precision=2)
284 | 
285 |         # get outliers
286 |         outliers = find_outlier_grids_distance(grids_grouped)
287 |         for outliers_pair in outliers:
288 |             ids_good, ids_bad = outliers_pair
289 |             if len(ids_bad) == 0:
290 |                 continue
291 |             # add bad ids to mark them later
292 |             ids_bad_to_override += ids_bad
293 | 
294 |             if len(ids_good) > 0:
295 |                 good_id = ids_good[0]
296 |                 print("Outliers from grid \"%s\" %s:" % (doc.GetElement(good_id).Name, \
297 |                                                          linkify(good_id)))
298 |             else:
299 |                 good_id = None
300 |                 print("Orphaned grids:")
301 | 
302 |             for g_id in ids_bad:
303 |                 g_name = doc.GetElement(g_id).Name
304 |                 if good_id:
305 |                     print("\"%s\" ( %s&deg; ) %s " % (g_name, \
306 |                                                       curve_angles[g_id] - curve_angles[good_id], linkify(g_id),))
307 |                 else:
308 |                     print("\"%s\" %s " % (g_name, linkify(g_id),))
309 | 
310 |             print("\n\n")
311 | 
312 |     if type(doc.ActiveView) == ViewPlan and len(ids_bad_to_override) > 0:
313 |         text = "Check completed\n%d errors found. Mark outliers grids on active plan view \"%s\"?" % (
314 |             len(ids_bad_to_override), doc.ActiveView.Name)
315 |         a = TaskDialog.Show(__title__, text,
316 |                             TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No)
317 | 
318 |         if a == "No":
319 |             return
320 | 
321 |         override_gray = OverrideGraphicSettings() \
322 |             .SetProjectionLineColor(Color(200, 200, 200))
323 | 
324 |         override_red = OverrideGraphicSettings().SetProjectionLineColor(Color(255, 0, 0)) \
325 |             .SetProjectionLineWeight(6)
326 | 
327 |         t = Transaction(doc)
328 |         t.Start("Override graphics")
329 | 
330 |         for g in grids:
331 |             doc.ActiveView.SetElementOverrides(g.Id, override_gray)
332 | 
333 |         grids_visible = get_grids(doc.ActiveView.Id, ids=True)
334 | 
335 |         for g in ids_bad_to_override:
336 |             if g not in grids_visible:
337 |                 line = doc.Create.NewDetailCurve(doc.ActiveView, doc.GetElement(g).Curve)
338 |                 doc.ActiveView.SetElementOverrides(line.Id, override_red)
339 |             doc.ActiveView.SetElementOverrides(g, override_red)
340 | 
341 |         t.Commit()
342 | 
343 |     if len(ids_bad_to_override) == 0:
344 |         TaskDialog.Show(__title__, "Check completed\n0 errors")
345 | 
346 | 
347 | def rotate_vector90(xyz):
348 |     return XYZ(xyz.Y, -xyz.X, xyz.Z)
349 | 
350 | 
351 | def rotate_curve(crv):
352 |     if not isinstance(crv, Line):
353 |         raise Exception("Crv is not a line")
354 |     curve = crv.Clone()
355 | 
356 |     end_point = curve.GetEndPoint(0)
357 |     curve.MakeUnbound()
358 |     return Line.CreateUnbound(end_point, rotate_vector90(curve.Direction))
359 | 
360 | 
361 | def test():
362 |     pairs = [
363 |         [458093, 754886],
364 |         [458133, 754997],
365 |         [755372, 755373]
366 |     ]
367 |     for p in pairs:
368 |         curve_first = None
369 |         last_point = None
370 |         for e_id_int in p:
371 |             print(e_id_int)
372 |             e = doc.GetElement(ElementId(e_id_int))
373 |             crv = e.Curve
374 |             if not curve_first:
375 |                 curve_first = rotate_curve(crv)
376 |             point = curve_location(crv, curve_first) # type : XYZ
377 |             if last_point is None:
378 |                 last_point = point
379 |             distance = point.DistanceTo(last_point)
380 |             print(distance * 304.8)
381 | 
382 | 
383 | if __name__ == '__main__':
384 |     # test()
385 |     run(interactive=True)
386 | 


--------------------------------------------------------------------------------
/pyApex.tab/Misc.panel/utils.stack/SortAndEnumerate.pushbutton/script.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | __title__ = 'Sort and enumerate'
  3 | __doc__ = """Sort selected objects, views or sheets by specified parameter, coordinate or along curve. 
  4 | Then write order number of each element as another parameter
  5 | 
  6 | Context: at least 2 objects must be selected
  7 | 
  8 | Сортирует выделенные объекты, виды или листы по определенному параметру, координате или вдоль линии.
  9 | Затем записывает порядковый номер каждого из объектов в другой параметр.
 10 | 
 11 | Контекст: как минимум 2 объекта должны быть выделены"""
 12 | 
 13 | __context__ = 'Selection'
 14 | 
 15 | __helpurl__ = "https://apex-project.github.io/pyApex/help#sort-and-enumerate"
 16 | 
 17 | import operator
 18 | 
 19 | from Autodesk.Revit.UI import TaskDialog, TaskDialogCommonButtons, Selection
 20 | from Autodesk.Revit.DB import BuiltInCategory, ElementId, Definition, StorageType
 21 | 
 22 | from Autodesk.Revit.DB import Transaction, TransactionGroup
 23 | 
 24 | from pyrevit import script, forms
 25 | from pyrevit.forms import WPFWindow
 26 | 
 27 | logger = script.get_logger()
 28 | from pyrevit.revit import doc, selection as _selection_pyr
 29 | from curve_chain import pick_chain, chain_closest_point
 30 | selection_pyr = _selection_pyr.get_selection()
 31 | selection_elements = selection_pyr.elements
 32 | my_config = script.get_config()
 33 | wpf_window = None
 34 | 
 35 | # def get_selection():
 36 | #     """
 37 | #     Get selected objects / sheets / views or allows user to select
 38 | #
 39 | #     :return: selected objects or None
 40 | #     """
 41 | #     return selection_doc.elements
 42 | 
 43 | def sort_joined_curves(curves):
 44 |     adjoinedcurves = curves
 45 |     count = 0
 46 |     end = 0
 47 |     while len(adjoinedcurves) > 0 and count < 100:
 48 |         c = curves[0]
 49 |         result = []
 50 |         adjoinedcurves = c.GetAdjoinedCurveElements(0)
 51 |         count += 1
 52 | 
 53 | class EnumerateWindow(WPFWindow):
 54 |     def __init__(self, xaml_file_name, selected_elements):
 55 |         is_geom_list, not_geom_list = self.separate_geometry(selected_elements)
 56 |         self.selection, self.is_geom = self.filter_geometry_and_other(is_geom_list, not_geom_list)
 57 | 
 58 |         self.extra_geom_keys = [
 59 |                                 "<Along curve>",
 60 |                                 "<X coordinate>",
 61 |                                 "<Y coordinate>",
 62 |                                 "<Z coordinate>"
 63 |                                 ]
 64 | 
 65 |         if not self.selection:
 66 |             logger.error("Selection error or wrong elements were selected")
 67 |             return
 68 | 
 69 |         parameters_dict = self.get_selection_parameters(self.selection)
 70 | 
 71 |         self.parameters_sortable = self.filter_sortable(self.selection, parameters_dict)
 72 |         self.parameters_editable = self.filter_editable(parameters_dict)
 73 | 
 74 |         WPFWindow.__init__(self, xaml_file_name)
 75 |         self._set_comboboxes()
 76 |         self.read_config()
 77 | 
 78 |     def read_config(self):
 79 |         # check are last parameters available
 80 |         try:
 81 |             if my_config.parameter_to_sort not in self.parameters_sortable:
 82 |                 my_config.parameter_to_sort = ""
 83 |         except:
 84 |             pass
 85 |         try:
 86 |             if my_config.parameter_to_set not in self.parameters_editable:
 87 |                 my_config.parameter_to_set = ""
 88 |         except:
 89 |             pass
 90 | 
 91 |         try:
 92 |             self.textFormat.Text = str(my_config.text_format)
 93 |         except:
 94 |             self.textFormat.Text = my_config.text_format = "%s"
 95 | 
 96 |         try:
 97 |             self.leadingZeros.Text = str(my_config.leading_zeros)
 98 |         except:
 99 |             self.leadingZeros.Text = my_config.leading_zeros = "0"
100 | 
101 |         try:
102 |             self.startFrom.Text = str(my_config.start_from)
103 |         except:
104 |             self.startFrom.Text = my_config.start_from = "1"
105 | 
106 |         try:
107 |             self.parameterToSort.Text = str(my_config.parameter_to_sort)
108 |         except:
109 |             self.parameterToSort.Text = my_config.parameter_to_sort = ""
110 | 
111 |         try:
112 |             self.parameterToSet.Text = str(my_config.parameter_to_set)
113 |         except:
114 |             self.parameterToSet.Text = my_config.parameter_to_set = ""
115 | 
116 |         try:
117 |             self.isReversed.IsChecked = my_config.is_reversed
118 |         except:
119 |             self.isReversed.IsChecked = my_config.is_reversed = False
120 | 
121 |         script.save_config()
122 | 
123 |     def write_config(self):
124 |         my_config.text_format = self.textFormat.Text
125 |         my_config.leading_zeros = self.leadingZeros.Text
126 |         my_config.parameter_to_sort = self.parameterToSort.Text
127 |         my_config.parameter_to_set = self.parameterToSet.Text
128 |         my_config.is_reversed = self.isReversed.IsChecked
129 |         script.save_config()
130 |     #
131 |     # def parameterToSort_changed(self, sender, args):
132 |     #     if sender.SelectedItem == "<Along curve>":
133 |     #         forms.alert("Select curve to sort along")
134 |     #         self.Hide()
135 |     #         try:
136 |     #             chain, chain_is_reversed = pick_chain(True)
137 |     #         except Exception as exc:
138 |     #             logger.error(exc)
139 |     #         self.Show()
140 |     #         logger.info(chain)
141 |     #         logger.info(chain_is_reversed)
142 |     #     elif sender.SelectedItem == "---" and self.parameterToSort.Text != "---":
143 |     #         self.parameterToSort.Text = self.parameterToSort.Text
144 | 
145 |     @property
146 |     def parameter_to_sort(self):
147 |         p = self.parameterToSort.Text
148 |         if not self.parameterToSort or self.parameterToSort.Text == "":
149 |             return
150 |         if type(p) == str and p in self.extra_geom_keys:
151 |             return p
152 |         else:
153 |             return self.parameters_sortable[p]
154 | 
155 |     @property
156 |     def parameter_to_set(self):
157 |         if not self.parameterToSet or self.parameterToSet.Text == "":
158 |             return
159 |         p = self.parameters_editable[self.parameterToSet.Text]
160 |         return p
161 | 
162 |     @property
163 |     def text_format(self):
164 |         t = self.textFormat.Text.strip()
165 |         if len(t) == 0:
166 |             return
167 | 
168 |         if "%s" not in t:
169 |             t += " %s"
170 | 
171 |         return t
172 | 
173 |     @property
174 |     def leading_zeros(self):
175 |         try:
176 |             n = int(self.leadingZeros.Text)
177 |         except:
178 |             n = 0
179 |         return n
180 | 
181 |     @property
182 |     def start_from(self):
183 |         return int(self.startFrom.Text)
184 | 
185 |     @property
186 |     def is_reversed(self):
187 |         return self.isReversed.IsChecked
188 | 
189 |     def run(self, sender, args):
190 |         # print(dir(self))
191 |         if not(self.parameter_to_sort and  self.parameter_to_sort != "" and self.parameter_to_set and  self.parameter_to_set != ""):
192 |             forms.alert("Error! All the parameters should be set")
193 |             return
194 | 
195 |         result = self.sort(self.selection, self.parameter_to_sort, self.is_reversed)
196 |         i = self.start_from
197 |         text_format = self.text_format
198 |         zeros = self.leading_zeros
199 | 
200 |         t = Transaction(doc, __title__)
201 |         t.Start()
202 |         for r in result:
203 |             e = r[0]
204 |             definition = self.parameter_to_set.Definition
205 |             param = e.get_Parameter(definition)
206 |             if zeros:
207 |                 _i = str(i).zfill(zeros)
208 |             else:
209 |                 _i = str(i)
210 |             self.parameter_value_set(param, _i, text_format)
211 |             i += 1
212 |         t.Commit()
213 | 
214 |         my_config.start_from = i
215 | 
216 |         # selection_doc.set self.selection
217 |         try:
218 |             self.write_config()
219 |         except:
220 |             pass
221 |         logger.debug("run - set_to", map(lambda e: e[0].Id.IntegerValue, result))
222 |         selection_pyr.set_to(map(lambda e: e[0].Id, result))
223 |         self.Close()
224 | 
225 | 
226 |     def sort(self, elements, parameter_to_sort, reverse=False):
227 |         param_dict = self.element_parameter_dict(elements, parameter_to_sort)
228 |         param_dict_sorted = sorted(param_dict.items(), key=operator.itemgetter(1), reverse=reverse)
229 |         return param_dict_sorted
230 |         # return map(lambda x: x[0], param_dict_sorted)
231 | 
232 | 
233 |     def element_parameter_dict(self, elements, parameter_to_sort):
234 |         result = {}
235 |         chain, chain_is_reversed = (None, None)
236 |         if parameter_to_sort == "<Along curve>":
237 |             forms.alert("Select curve to sort along")
238 |             self.Hide()
239 |             try:
240 |                 chain, chain_is_reversed = pick_chain(doc)
241 |             except Exception as exc:
242 |                 logger.error(exc)
243 |             self.Show()
244 |             logger.debug(chain)
245 |             logger.debug(chain_is_reversed)
246 | 
247 |         for e in elements:
248 |             if type(parameter_to_sort) == str:
249 |                 if parameter_to_sort[0] == "<" and parameter_to_sort[2:] == " coordinate>":
250 |                     parameter_loc = parameter_to_sort[1]
251 |                     loc_point = e.Location.Point
252 |                     v = getattr(loc_point, parameter_loc)
253 |                 elif parameter_to_sort == "<Along curve>" and chain:
254 |                     logger.debug("<Along curve>")
255 |                     loc_point = e.Location.Point
256 |                     v = chain_closest_point(loc_point, chain, chain_is_reversed, doc)
257 |                 else:
258 |                     logger.error("Parameter error")
259 |                     return
260 |             else:
261 |                 param = e.get_Parameter(parameter_to_sort.Definition)
262 |                 v = self.parameter_value_get(param)
263 |             if v:
264 |                 logger.debug("v: %s" % v)
265 |                 result[e] = v
266 | 
267 |         return result
268 | 
269 |     def parameter_value_get(self, parameter):
270 |         if not parameter.HasValue:
271 |             return
272 | 
273 |         if parameter.StorageType == StorageType.Double:
274 |             x = float(parameter.AsDouble())
275 |         elif parameter.StorageType == StorageType.Integer:
276 |             x = int(parameter.AsInteger())
277 |         else:
278 |             try:
279 |                 x = float(parameter.AsString().strip().replace(",", "."))
280 |             except:
281 |                 x = parameter.AsString()
282 |         return x
283 | 
284 |     def parameter_value_set(self, parameter, value, text_format):
285 |         if parameter.StorageType == StorageType.Double or parameter.StorageType == StorageType.Integer:
286 |             if text_format:
287 |                 try:
288 |                     value = str(float(text_format % value))
289 |                 except:
290 |                     pass
291 |             parameter.SetValueString(value)
292 |         else:
293 |             if text_format:
294 |                 parameter.Set(text_format % value)
295 |             else:
296 |                 parameter.Set(value)
297 | 
298 |     def _set_comboboxes(self):
299 |         sortable_keys = self.parameters_sortable.keys()
300 | 
301 |         if self.is_geom:
302 |             sortable_keys += ["---"]
303 |             sortable_keys += self.extra_geom_keys
304 | 
305 |         self.parameterToSort.ItemsSource = sortable_keys
306 |         self.parameterToSet.ItemsSource = self.parameters_editable.keys()
307 | 
308 |     def separate_geometry(self, selection):
309 |         """
310 |         Check is most of elements have
311 |         :param selection: list of elements
312 |         :return: [[list of geometry], [list of other elements]]
313 |         """
314 |         is_geom = []
315 |         not_geom = []
316 | 
317 |         for e in selection:
318 |             if e.Location:
319 |                 is_geom.append(e)
320 |             else:
321 |                 not_geom.append(e)
322 | 
323 |         return is_geom, not_geom
324 | 
325 |     def filter_geometry_and_other(self, is_geom, not_geom):
326 |         elements = None
327 |         is_geom_bool = None
328 | 
329 |         if not_geom and is_geom:
330 |             errors_string = "Selection has %d geometry objects and %d other objects.\n" % (len(is_geom), len(not_geom),)
331 | 
332 |             if len(is_geom) > len(is_geom):
333 |                 q = TaskDialog.Show(__title__, errors_string + "Only geometry will be used.",
334 |                                     TaskDialogCommonButtons.Ok | TaskDialogCommonButtons.Cancel)
335 |                 elements = is_geom
336 |                 is_geom_bool = True
337 |             else:
338 |                 q = TaskDialog.Show(__title__, errors_string + "Only not-geometry elements will be used.",
339 |                                     TaskDialogCommonButtons.Ok | TaskDialogCommonButtons.Cancel)
340 |                 elements = not_geom
341 |                 is_geom_bool = False
342 |             if str(q) == "Cancel":
343 |                 return
344 |         elif not_geom or is_geom:
345 |             elements = is_geom if is_geom else not_geom
346 |             is_geom_bool = True if is_geom else False
347 | 
348 |         return elements, is_geom_bool
349 | 
350 |     def get_selection_parameters(self, elements):
351 |         """
352 |         Get parameters which are common for all selected elements
353 | 
354 |         :param elements: Elements list
355 |         :return: dict - {parameter_name: Parameter}
356 |         """
357 |         result = {}
358 |         all_parameter_set = set()
359 |         all_parameter_ids_by_element = {}
360 | 
361 |         # find all ids
362 |         for e in elements:
363 |             for p in e.Parameters:
364 |                 p_id = p.Definition.Id
365 |                 all_parameter_set.add(p)
366 | 
367 |                 if e.Id not in all_parameter_ids_by_element.keys():
368 |                     all_parameter_ids_by_element[e.Id] = set()
369 |                 all_parameter_ids_by_element[e.Id].add(p_id)
370 | 
371 |         # filter
372 |         for p in all_parameter_set:
373 |             p_id = p.Definition.Id
374 |             exists_for_all_elements = True
375 |             for e_id, e_params in all_parameter_ids_by_element.items():
376 |                 if p_id not in e_params:
377 |                     exists_for_all_elements = False
378 |                     break
379 | 
380 |             if exists_for_all_elements:
381 |                 result[p.Definition.Name] = p
382 | 
383 |         return result
384 | 
385 |     def filter_sortable(self, elements, parameters):
386 |         """
387 |         Filter parameters which has value for at least some of elements
388 | 
389 |         :param elements: list of elements
390 |         :param parameters: list of parameters
391 |         :return: filtered list of parameters
392 |         """
393 |         result = {}
394 |         for p_name, p in parameters.items():
395 |             for e in elements:
396 |                 param = e.get_Parameter(p.Definition)
397 |                 if param:
398 |                     # TODO figure out why param is None here
399 |                     if param.HasValue:
400 |                         result[p_name] = p
401 |                         break
402 |         return result
403 | 
404 |     def filter_editable(self, parameters):
405 |         """
406 |         Filter parameters which can be modified by users
407 | 
408 |         :param parameters: list of parameters
409 |         :return: filtered list of parameters
410 |         """
411 |         ignore_types = [StorageType.ElementId, ]
412 |         result = {n: p for n, p in parameters.iteritems()
413 |                   if not p.IsReadOnly
414 |                   and p.StorageType not in ignore_types}
415 |         return result
416 | 
417 |     def NumberValidationTextBox(self, sender, e):
418 |         try:
419 |             x = int(e.Text.strip())
420 |             e.Handled = False
421 |             return x
422 | 
423 |         except:
424 |             e.Handled = True
425 | 
426 | 
427 | def main():
428 |     global wpf_window
429 |     # Input
430 |     if not selection_elements:
431 |         logger.error("Nothing selected")
432 |         return
433 | 
434 |     if len(selection_elements) < 2:
435 |         logger.error('At least 2 elements or views must be selected.')
436 |         return
437 | 
438 |     logger.debug("main - selection", map(lambda e: e.Id.IntegerValue, selection_elements))
439 |     wpf_window = EnumerateWindow('window.xaml', selection_elements)
440 |     # print(dir(wpf_window))
441 |     wpf_window.show(True)
442 |     # print(dir(wpf_window))
443 | 
444 | 
445 | 
446 | if __name__ == "__main__":
447 |     main()
448 | 


--------------------------------------------------------------------------------