= Izdelava modelov z OpenCascade =
[[PageOutline]]

== Struktura programa v Python OCC ==

Rabimo uvoziti uporabniški vmesnik, ki nam omogoči preprosto manipulacijo 
predstavljenega objekta (glava dokumenta):
{{{
#!python
from OCC.Display.SimpleGui import *
}}}
Z ukazno vrstico uvozimo v program knjižnico, ki vsebuje modelno okno ter preprosti uporabniški vmesnik, ki ga lahko uporabimo za prikaz različnih geometrijskih oblik v 3D okolju.
[[BR]][[BR]]

Uvedba funkcij za iniciacijo prikaza:
{{{
#!python
display, start_display, add_menu, add_function_to_menu = init_display()
}}}
Z ukazno vrstico uvedemo v program prikaz v modelnem oknu ter možnost uporabe preprostega menija.
[[BR]][[BR]]

Iniciacija prikaznega okna:
{{{
#!python
start_display()
}}}
S tem ukazom iniciramo modelno okno. Definicija uporabljenih geometrijskih oblik mora biti podana preden se ukaz izvede.[[Image(display.png, 500, right)]]
[[BR]][[BR]][[BR]][[BR]]

Uporaba miške v uporabniškem vmesniku:
 * Rotacija objekta: levi gumb na miški
 * Translacija objekta: srednji gumb na miški
 * Povečava objekta: desni gumb na miški, premik levo-desno
[[BR]]

Uporaba tipkovnice v uporabniškem vmesniku:
 * Tipka 'w'- prikaz žičnega modela
 * Tipka 's'- prikaz volumskega modela
 * Tipka 'f'- prikaz celega objekta v prikaznem oknu
[[BR]][[BR]][[BR]][[BR]][[BR]]


Za izdelavo modela v okolju Python OCC je potrebna predhodna uvedba knjižnic OpenCascade (OCC), ki vsebujejo različne nabore ukazov:
{{{
#!python
from OCC.Display.SimpleGui import *  # Knjižnica z modelnim oknom ter uporabniškim vmesnikom (GUI)
from OCC.gp import *                 # Knjižnica z naborom osnovnih gradnikov -točk
from OCC.GC import *                 # 
from OCC.TopoDS import *             # Knjižnica z naborom topoloških gradnikov (krivulje,...)
from OCC.BRepBuilderAPI import *     # Knjižnica z naborom osnovnih gradnikov skice (vozlišča, robovi, segmenti, mreže ...)
from OCC.BRepPrimAPI import *        # Knjižnica z naborom osnovnih geometrijskih primitivov
from OCC.BRepFilletAPI import *      # Knjižnica z naborom orodij za izdelavo zaokrožitev
}}}
V program uvedemo zgolj knjižnice, ki jih tudi rabimo za učinkovito delovanje.
[[BR]][[BR]][[BR]]
----


== Preprosti program- Primer izdelave izvleka v prostor (Extrude) ==

Primer izdelave kocke z dimenzijami 10x10x10. Postopek modeliranja v [[Image(Kocka.png, 300, right)]]
komercialnih modelirnikih (SolidWorks, Catia, NX, ProEngineer, Inventor,...)
je sledeči:
 * izbira ravnine, na katero se nariše skica[[BR]][[BR]]
 * izris oblike skice (kvadrat)[[BR]][[BR]]
 * definiranje skice (dimenzije, geometrijske relacije, pozicija v prostoru)[[BR]][[BR]]
 * izbira ustrezne značilke za izdelavo 3D objekta (Izvlek- Extrude)[[BR]][[BR]]
 * določitev parametrov izvleka (smer, dolžina izvleka)[[BR]][[BR]]
 * model je zmodeliran
[[BR]][[BR]][[BR]][[BR]]

V okolju Python OCC poteka izris objekta nekoliko drugače. Razložen je 
preprosti postopek izdelave kocke, ki poteka v večih korakih. Pri izdelavi
je potrebno manualno določiti vse parametre, ki jih komercialni modelirnik
običajno določi namesto nas.[[BR]][[BR]]

Korak 01: Izdelava točke v prostoru [[Image(Vozlisca.png, 300, right)]]
Razlaga ukaza za izdelavo točke [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classgp__Pnt.html gp__Pnt]
{{{
#!python
Tocka = gp_Pnt(x_1 , y_1 , z_1)
}}}
Iz določenih točk lahko naredimo vozlišča. Detajlna razlaga uporabljenega ukaza: [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepLib__MakeVertex.html BRepBuilderAPI__MakeVertex].
{{{
#!python
Vozlisce = BRepBuilderAPI_MakeVertex(Tocka)
}}}
Če hočemo prikazati vozlišča v modelnem oknu, potem je potrebno napisati ukaz za prikaz oblike:
{{{
#!python
display.DisplayShape(Vozlisce.Shape())
}}}
[[BR]][[BR]][[BR]]


Korak 02: Izdelava robov iz točk [[Image(Robovi.png, 300, right)]]
{{{
#!python
Rob = BRepBuilderAPI_MakeEdge(Zacetna_tocka, Koncna_tocka)
}}}
Za izdelavo roba rabimo dva podatka, to je začetna točka ter končna točka robu. Detajlna razlaga 
uporabljenega ukaza: [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepLib__MakeEdge.html BRepBuilderAPI__MakeEdge]. Če hočemo 
prikazati izdelani rob v modelnem oknu, je potrebno zapisati ukaz:
{{{
#!python
display.DisplayShape(Rob.Shape())
}}}
V primeru, da želimo narediti rob s krožnim lokom uporabimo knjižnico
{{{
#!python
from OCC.GC import *
}}}
in ukaz
{{{
#!python
aArcOfCircle1 = GC_MakeArcOfCircle(zacetna_tocka, dodatna_tocka_na_kroznici, koncna_tocka)
}}}
[[BR]][[BR]][[BR]][[BR]][[BR]][[BR]]

Korak 03: Izdelava mrežnega modela iz točk [[Image(Wire.png, 300, right)]]
{{{
#!python
Mreza  = BRepBuilderAPI_MakeWire(Rob1.Edge() , Rob2.Edge() ,Rob3.Edge(), Rob4.Edge())
Mreza2  = BRepBuilderAPI_MakeWire(Mreza.Wire(), Rob1.Edge())
}}}
Ukaz BRepBuilderAPI_MakeWire() sprejme le štiri argumente, tako da lahko na ta način sestavimo le mrežo s štirimi robovi. Če želimo narediti mrežo z več robovi lahko definiramo več posameznih mrež in jih nato skupaj sestavimo.
{{{
#!python
Mreza1  = BRepBuilderAPI_MakeWire(Rob1.Edge() , Rob2.Edge() ,Rob3.Edge(), Rob4.Edge())
Mreza2  = BRepBuilderAPI_MakeWire(Rob5.Edge(), Rob6.Edge())
Mreza1.Add(Mreza2.Wire()) #Mreži Mreza1 dodamo še mrežo Mreza2 in ju tako združimo skupaj
}}}
Vsak rob predstavlja svojo geometrijsko obliko v prostoru. Zato moramo, preden naredimo
površino te robove združiti v eno samo geometrijo. Pozorni moramo biti, da robovi tvorijo
zaprto obliko. Ukaz nam dovoli sočasno uporabo štirih argumentov- robov. Pri tem moramo
označiti, da gre za obliko roba [Rob.Edge()]. Kot rezultat dobimo združeno mrežo. Detajlna 
razlaga uporabljenega ukaza: [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepBuilderAPI__MakeWire.html BRepBuilderAPI__MakeWire]
Če hočemo prikazati izdelani rob v modelnem oknu, je potrebno zapisati ukaz:
{{{
#!python
display.DisplayShape(Mreza.Shape())
}}}
[[BR]][[BR]][[BR]][[BR]]

Korak 04: Izdelava površine iz obstoječe mreže [[Image(Povrsina.png, 300, right)]]
{{{
#!python
Povrsina = BRepBuilderAPI_MakeFace(Mreza.Wire())
}}}
Iz obstoječega zaprtega lika, ki je planaren lahko tvorimo površino. Detajlna razlaga 
uporabljenega ukaza: [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepBuilderAPI__MakeFace.html BRepBuilderAPI__MakeFace]
Če hočemo prikazati izdelani rob v modelnem oknu, je potrebno zapisati ukaz:
{{{
#!python
display.DisplayShape(Povrsina.Shape())
}}}
[[BR]][[BR]][[BR]][[BR]][[BR]][[BR]]

Korak 05: Izdelava izvleka v prostor [[Image(Solid.png, 300, right)]]
Izdelano površino lahko uporabimo za izdelavo tridimenzionalne oblike. Če hočemo narediti 
izvlek, je potrebno najprej določiti še parametre vičine izvleka. V ta namen določimo vektor, 
ki vsebuje podatek o velikosti in smeri izvleka. Razlaga uporabljenega ukaza: [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classgp__Vec.html gp_Vec].
{{{
#!python
Vektor = gp_Vec(Velikost_X , Velikost_Y, Velikost_Z)
}}}
Sledi uporaba ukaza za izdelavo izvleka. Pri tem je potrebno uporabiti podatek o površini ter 
izdelani vektor. Če hočemo, lahko naredimo tudi neskončno dolgi izvlek v prostor, tako da uporabimo 
zgolj podatek o izbrani smeri namesto določenega vektorja (uporaba pri Boolovi operaciji odštevanja).
Razlaga uporabljenega ukaza: [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepFeat__MakePrism.html BRepFeat__MakePrism].
{{{
#!python
Izvlek = BRepPrimAPI_MakePrism(Povrsina.Face() , Vektor)
Izvlek = BRepPrimAPI_MakePrism(Povrsina.Face() , Smer)
}}}

Primer za "smer": smer = gp_Dir(gp_XYZ(0,0,1))
[[BR]][[BR]]

Barvo modela lhako po želji spremenimo z uporabo ukaza:
{{{
#!python
display.DisplayColoredShape(Oblika.Shape(), 'BARVA')
}}}
[[BR]][[BR]]

Primer programa za izdelavo izvleka:[[Image(Solid-barve.png, 300, right)]]
{{{
#!python
## Izdelava Izvleka

from OCC.Display.SimpleGui import * 
from OCC.BRepPrimAPI import *
from OCC.gp import *
from OCC.GC import *
from OCC.BRepBuilderAPI import *

display, start_display, add_menu, add_function_to_menu = init_display()

#Izdelava točk v prostoru
T1 = gp_Pnt(0 , 0 , 0)
T2 = gp_Pnt(10 , 0, 0)
T3 = gp_Pnt(10 , 10 , 0)
T4 = gp_Pnt(0, 10 , 0)

#izdelava robov na podlagi definiranih tock
E1 = BRepBuilderAPI_MakeEdge(T1, T2)
E2 = BRepBuilderAPI_MakeEdge(T2, T3)
E3 = BRepBuilderAPI_MakeEdge(T3, T4)
E4 = BRepBuilderAPI_MakeEdge(T4, T1)

#izdelava mreznega modela
Mreza  = BRepBuilderAPI_MakeWire(E1.Edge() , E2.Edge() ,E3.Edge(), E4.Edge())

#Izdelava povrsine
Povrsina = BRepBuilderAPI_MakeFace(Mreza.Wire())

#Izdelava vektorja za izvlek v prostor
Vektor1 = gp_Vec(0 , 0, 10)

#Izdelava priznaticnega telesa- izvlek povrsine v smeri vektorja
Izvlek = BRepPrimAPI_MakePrism(Povrsina.Face() , Vektor1)

#Prikaz izvleka v prikaznem oknu
display.DisplayShape(Izvlek.Shape())

#Sprememba barve modela
display.DisplayColoredShape(Izvlek.Shape(), 'RED')

display.View_Iso() #izometricni prikaz
start_display()
}}}
----


== Uporaba geometrijskih primitivov ==

=== Izdelava kvadra ===
[[Image(Kvader.png, 300, right)]]
{{{
#!python
kvader = BRepPrimAPI_MakeBox(dolzina_X, dolzina_Y, dolzina_Z)
kvader = BRepPrimAPI_MakeBox(Tocka1, dolzina_X, dolzina_Y, dolzina_Z)
kvader = BRepPrimAPI_MakeBox(Tocka1, Tocka2)
}}}
Z ukazom [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepPrimAPI__MakeBox.html BRepPrimAPI__MakeBox] izdelamo tridimenzionalni model oblike kvadra. Pri tem lahko uporabimo več različnih argumentov:
 * (dolzina_X, dolzina_Y, dolzina_Z) ... kvader določimo z razdaljami posameznih robov[[BR]][[BR]]
 * (Tocka1, dolzina_X, dolzina_Y, dolzina_Z) ... kvader se prične izrisovati od točke 1 (X,Y,Z) dalje inje določen z razdaljami posameznih robov[[BR]][[BR]]
 * (Tocka 1, Tocka2) ... kvader določimo s koordinatami dveh točk, ki ježita v nasproti ležečih ogliščih
[[BR]]


=== Izdelava izvleka pod kotom nagiba ===
[[Image(Kvader-nagib.png, 600, right)]]
{{{
#!python
kvader= BRepPrimAPI_MakeWedge(dolzina_X, dolzina_Y, dolzina_Z, dolzina_X2)
kvader= BRepPrimAPI_MakeWedge(dolzina_X, dolzina_Y, dolzina_Z, dolzina_Xmin, dolzina_Zmin, dolzina_Xmax, dolzina_Zmax)
kvader= BRepPrimAPI_MakeWedge(dolzina_X, dolzina_Y, dolzina_Z, dolzina_X/2, 0, dolzina_X/2, dolzina_Z)
kvader= BRepPrimAPI_MakeWedge(dolzina_X, dolzina_Y, dolzina_Z, dolzina_X/2, dolzina_Z/2, dolzina_X/2, dolzina_Z/2)
}}}
Z ukazom [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepPrimAPI__MakeWedge.html BRepPrimAPI__MakeWedge] izdelamo tridimenzionalni model oblike kvadra s koti nagiba. Pri tem lahko uporabimo več različnih argumentov:
 * (dolzina_X, dolzina_Y, dolzina_Z, dolzina_X2) ... določimo razdalje posameznih robov kvadra, ter dimenzijo spremenjenega roba X[[BR]][[BR]]
 * (dolzina_X, dolzina_Y, dolzina_Z, dolzina_Xmin, dolzina_Zmin, dolzina_Xmax, dolzina_Zmax) ... določimo razdalje posameznih robov kvadra, ter minimalne in maksimalne dimenzije robov X in Z
 * (dolzina_X, dolzina_Y, dolzina_Z, dolzina_X/2, 0, dolzina_X/2, dolzina_Z) ... določimo razdalje posameznih robov kvadra, ter dimenzijo spremenjenega roba Z[[BR]][[BR]]
 * (dolzina_X, dolzina_Y, dolzina_Z, dolzina_X/2, dolzina_Z/2, dolzina_X/2, dolzina_Z/2)... določimo razdalje posameznih robov kvadra, preostali argumenti nam podajo obliko piramide
[[BR]]


=== Izdelava valja ===
[[Image(Valj.png, 600, right)]]
{{{
#!python
valj= BRepPrimAPI_MakeCylinder(Radij, Visina)
valj= BRepPrimAPI_MakeCylinder(Radij, Visina, Kot_radiani)
valj= BRepPrimAPI_MakeCylinder(Os, Radij, Visina, Kot_radiani)
valj = BRepPrimAPI_MakeCylinder(Os_Definicija(Točka, Smer), Radij, Visina)
}}}
Z ukazom [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepPrimAPI__MakeCylinder.html BRepPrimAPI__MakeCylinder] izdelamo tridimenzionalni model oblike valja. Pri tem lahko uporabimo več različnih argumentov:
 * (Radij, Visina) ... izdelamo valj z določenim radijem in višino
 * (Radij, Visina, Kot_radiani) ... izdelamo delj valja za nastavljen kot z določenim radijem in višino
 * (Os, Radij, Visina, Kot_radiani) ... izdelamo delj valja za nastavljen kot z določenim radijem in višino in ki ima nastavljeno poljubno os

Os valja definiramo kot:
{{{
#!python
Tocka = gp_Pnt(X, Y, Z)         #definicija tocke
normala = gp_DX()               #smer normale. Lahko tudi gp_Dir(1, 0, 0). Za smer v Y oz. Z osi: gp_DY() oz. gp_DZ(). 
os = gp_Ax1(Tocka, normala)     #definicija osi
}}}



=== Izdelava stožca ===
[[Image(Stozec.png, 600, right)]]
{{{
#!python
stozec= BRepPrimAPI_MakeCone(Radij_1, Radij_2, Visina, Kot_radiani)
stozec= BRepPrimAPI_MakeCone(Os, Radij_1, Radij_2, Visina, Kot_radiani)
}}}
Z ukazom [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepPrimAPI__MakeCone.html BRepPrimAPI__MakeCone] izdelamo tridimenzionalni model oblike stožca. Pri tem lahko uporabimo več različnih argumentov:
 * (Radij_1, Radij_2, Visina) ... izdelamo stožec z osnovo radija 1 ter na višini H z radijem 2[[BR]][[BR]]
 * (Radij_1, Radij_2, Visina, Kot_radiani) ... izdelamo delni stožec, določen s kotom, z osnovo radija 1 ter na višini H z radijem 2[[BR]][[BR]]
 * (Os, Radij_1, Radij_2, Visina, Kot_radiani) ... izdelamo delni stožec okoli izbrane osi, določen s kotom, z osnovo radija 1 ter na višini H z radijem 2
[[BR]][[BR]][[BR]][[BR]][[BR]]


=== Izdelava sfere ===
[[Image(Sfera.png, 600, right)]]
{{{
#!python
sphere= BRepPrimAPI_MakeSphere(Radij, Kot_radiani)
sphere= BRepPrimAPI_MakeSphere(Radij, Kot_a1_rad, Kot_a2_rad)
sphere= BRepPrimAPI_MakeSphere(Radij, Kot_a1_rad, Kot_a2_rad, Kot_radiani)
}}}
Z ukazom [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepPrimAPI__MakeSphere.html BRepPrimAPI__MakeSphere] izdelamo tridimenzionalni model oblike sfere. Pri tem lahko uporabimo več različnih argumentov:
 * (Radij) ... izdelave sfere z radijem
 * (Radij, Kot_radiani) ... izdelave delne sfere z radijem
 * (Radij, Kot_a1_rad, Kot_a2_rad) ... izdelave sfere, ki ima odstanjen sredinski del pod kotom 1 in kotom 2[[BR]][[BR]]
 * (Radij, Kot_a1_rad, Kot_a2_rad, Kot_radiani) ... izdelave delne sfere, ki ima odstanjen sredinski del pod kotom 1 in kotom 2

Opomba: Kot_a1 in Kot_a2 se morata gibati med -pi/2 in pi/2.
[[BR]][[BR]][[BR]][[BR]][[BR]]


=== Izdelava torusa ===
[[Image(Torus.png, 600, right)]]
{{{
#!python
torus= BRepPrimAPI_MakeTorus(Radij_torusa, Radij_prereza)
torus= BRepPrimAPI_MakeTorus(Radij_torusa, Radij_prereza, Kot_radiani)
torus= BRepPrimAPI_MakeTorus(Radij_torusa, Radij_prereza, Kot_a1_rad, Kot_a2_rad)
}}}
Z ukazom [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepPrimAPI__MakeTorus.html BRepPrimAPI__MakeTorus] izdelamo tridimenzionalni model oblike torusa. Pri tem lahko uporabimo več različnih argumentov:
 * (Radij_torusa, Radij_prereza) ... izdelava torusa s središčnim radijem ter polmerom prereza[[BR]][[BR]]
 * (Radij_torusa, Radij_prereza, Kot_radiani) ... izdelava delnega torusa s središčnim radijem ter polmerom prereza[[BR]][[BR]]
 * (Radij_torusa, Radij_prereza, Kot_a1_rad, Kot_a2_rad) ... izdelava delnega torusa, ki ima odstanjen sredinski del pod kotom 1 in kotom 2
[[BR]][[BR]][[BR]][[BR]]


=== Izdelava izvleka ===
[[Image(Izvlek_2.png, 600, right)]]
{{{
#!python
Izvlek = BRepPrimAPI_MakePrism(Povrsina , Vektor)
Izvlek = BRepPrimAPI_MakePrism(Povrsina , Smer)
}}}
Z ukazom [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepPrimAPI__MakePrism.html BRepPrimAPI__MakePrism] izdelamo tridimenzionalni prizmatični model. Pri tem lahko uporabimo več različnih argumentov:
 * (Povrsina , Vektor) ... izberemo obstoječo površino ter jo izvlečemo za velikost vektorja
 * (Povrsina , Smer) ... izberemo obstoječo površino ter jo izvlečemo v željeni smeri
[[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]]


=== Izdelava krožnega izvleka ===
[[Image(Izvlek_krozni.png, 600, right)]]
{{{
#!python
Vrtenina = BRepPrimAPI_MakeRevol(Povrsina , Os)
Vrtenina = BRepPrimAPI_MakeRevol(Povrsina , Os, Kot_radiani)
}}}
Z ukazom [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepPrimAPI__MakeRevol.html BRepPrimAPI__MakeRevol] izdelamo tridimenzionalni osnosimetričnimodel. Pri tem lahko uporabimo več različnih argumentov:
 * (Povrsina , Os) ... zavrtimo izbrano površino okoli osi
 * (Povrsina , Os, Kot_radiani) ... zavrtimo izbrano površino za kot okoli osi
[[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]]
----

== Uporaba menijev znotraj prikaznega okna ==
[[Image(Meniji.png, 600, right)]]

Najprej je potrebno definirati funkcije, ki izvršijo ukaz (izdelajo neko obliko). Pri tem pred izrisom oblike počistimo modelno okno obstoječih oblik z ukazom [display.EraseAll()].
{{{
#!python
def Funkcija(event=None):
    display.EraseAll()
    #definicija prikazane oblike
    display.DisplayShape(Oblika.Shape())
}}}

Izdelava menija
{{{
#!python
add_menu('Ime_menija')
add_function_to_menu('Ime_menija',Funkcija1)
add_function_to_menu('Ime_menija',Funkcija2)
}}}
[[BR]][[BR]]


== Boolova algebra ==
Poznamo tri operacije Boolove algebre: Seštevanje, Odštevanje ter Presek. Za uporabo imamo na voljo knjižnico ukazov BRepAlgoAPI.
{{{
#!python
from OCC.BRepAlgoAPI import *
}}}  
[[BR]][[BR]]

Seštevanje (Fusion) [[Image(20.png, 300, right)]]  [[BR]][[BR]]
Operacija seštevanja objektov se izvaja z uporabo ukaza [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepAlgoAPI__Fuse.html BRepAlgoAPI__Fuse], kjer dodamo kot argumente 3D obliki, ki ju želimo združiti:
{{{
#!python
sestevanje = BRepAlgoAPI_Fuse(Oblika1,Oblika2)
}}}
[[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]]


Presek (Common) [[Image(21.png, 300, right)]]  [[BR]][[BR]]
Operacija izdelave preseka objektov se izvaja z uporabo ukaza [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepAlgoAPI__Common.html BRepAlgoAPI__Common], kjer dodamo kot argumente 3D obliki, med katerimi želimo poiskati skupni volumen:
{{{
#!python
presek = BRepAlgoAPI_Common(Oblika1,Oblika2)
}}}
[[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]]


Odštevanje (Cut) [[Image(22.png, 600, right)]]  [[BR]][[BR]]
Operacija odštevanjaobjektov se izvaja z uporabo ukaza [http://opencascade.sourcearchive.com/documentation/6.3.0.dfsg.1/classBRepAlgoAPI__Cut.html BRepAlgoAPI__Cut], kjer dodamo kot argumente 3D obliki. Prvi argument predstavlja osnovno obliko, drugi argument pa predstavlja geometrijo, ki jo odštevamo. Vrstni red je v tem primeru pomemben!
{{{
#!python
odstevanje = BRepAlgoAPI_Cut(Objekt1, Objekt2)
}}}
[[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]]


== Geometrijske transformacije ==
Translacija objekta (Transform) [[Image(23.png, 600, right)]] [[BR]][[BR]]
Za premik objekta v prostoru se uporabi funkcija za translacijo. Pri tem je potrebno najprej določiti vektor premika, nato pa izberemo obliko, ki jo želimo premakniti v prostoru. Preprosta koda je zapisana:
{{{
#!python
Premik = gp_Vec(U_X, U_Y, U_Z)
Translacija = gp_Trsf()
Translacija.SetTranslation(Premik)
rezultat = BRepBuilderAPI_Transform(Oblika, Translacija).Shape()
}}}
[[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]]


Rotacija objekta (Rotation) [[Image(24.png, 600, right)]]  [[BR]][[BR]]
V kolikor želimo obstoječi objekt rotirati, je potrebno določiti najprej referenčno točko, ki služi kot lokacija osi vrtenja, ter nato določiti še rotacijsko os s smerjo vektorja. Potrebno je tudi določiti kot rotacije, ki ga določimo v radianih. Nazadnje izberemeo obliko, ki jo hočemo zavrteti okoli izbrane osi. Preprosti algoritem je zapisan:
{{{
#!python
LokacijaOsi = gp_Pnt(U_X, U_Y, U_Z)
RotacijaOs = gp_Ax1(LokacijaOsi, gp_Dir(Smer_X,Smer_Y,Smer_Z))
TransfRot = gp_Trsf()
TransfRot.SetRotation(RotacijaOs, Kot_radiani)
rezultat = BRepBuilderAPI_Transform(Oblika, TransfRot).Shape()
}}}
[[BR]][[BR]][[BR]][[BR]]


Povečava objekta (Scale) [[Image(24a.png, 300, right)]]  [[BR]][[BR]]
Objektu lahko spremmenimo  velikost tudi po tem, ko je le ta enkrat že narejen. To napravimo z uporabo orodja za povečavo. Pri tem rabimo določiti referenčno točko za izvajanje geometrijske operacije ter merilo (povečavo objekta). Nazadnje izberemeo obliko, ki ji hočemo spremeniti merilo. Preprosti algoritem je zapisan:
{{{
#!python
Tocka = gp_Pnt(0 , 0 , 0)
Povecava = gp_Trsf()
Povecava.SetScale(Tocka,merilo)
rezultat = BRepBuilderAPI_Transform(Oblika Povecava).Shape()
}}}
[[BR]][[BR]][[BR]][[BR]][[BR]][[BR]]


== Aplicirane značilke ==
Podobno kot pri komercialno dostopnih modelirnikih, lahko obstoječo geometrijo naknadno preoblikujemo z uporabo apliciranih značilk. Glavna lastnost apliciranih značilk je, da ne morejo obstajati kot samostojni predmet, ampak rabijo neko predhodno zmodelirano 3D geometrijo, ki jo nato spremenimo. Poznamo mnogo različnih apliciranih značilk. Nekatere izmed njih bomo razložili v tem poglavju.
[[BR]][[BR]]

=== Izdelava zaokrožitev (Fillet) ===
Poznamo dve vrsti zaokrožitve; zaokrožitev s konstantnim radiem zaokrožitve ter zaokrožitev s sprejemljivim radiem zaokrožitve.
Knjižnica ukazov za izdelavo zaokrožitev se nahaja v viru BRepFilletAPI in jo je potrebno vključiti v program pred uporabo ukaza:
{{{
#!python      
from OCC.BRepFilletAPI import * 
from OCC.TopExp import *
from OCC.TopAbs import *
from OCC.TopTools import *
from OCC.TopoDS import *
from OCC.TColgp import *
from OCC.Display.OCCViewer import *
}}}
Pri apliciranju vseh vrst zaokrožitev je potrebno imeti podatek o robu oziroma točki kamor hočemo izvesti zaokrožitev ter o parametrih zaokrožitve (radij zaokrožitve).

==== Zaokrožitev s konstantnim radiem zaokrožitve ====
Prvi korak je izbira objekta, na katerem se izvede zaokrožitev: [[Image(25.png, 600, right)]]
{{{
#!python
zaokrozitev = BRepFilletAPI_MakeFillet(Oblika)
}}}
Sledi izbira robov ter parametrov zaokrožitve. Primer, ko izvedemo zaokrožitev na vseh robovih elementa:
{{{
#!python
anEdgeExplorer = TopExp_Explorer(oblika, TopAbs_EDGE)

    while anEdgeExplorer.More():
        anEdge = topods.Edge(anEdgeExplorer.Current())
        zaokrozitev.Add(Radij_1, anEdge)
        #zaokrozitev.Add(Radij_1, Radij_2, anEdge)
        anEdgeExplorer.Next()

    zaokrozitev.Build()
    oblika = zaokrozitev.Shape()
}}}
[[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]] [[Image(26.png, 300, right)]]
Za izbiro točno določenih robov, na katerih hočemo izvesti zakrožitve, je potrebno vpeljati različne geometrijske teste. Primer, ko hočemo zakrožiti zgolj vertikalne robove kocke. Vpeljemo preprosti test, ki nam pove, če točki robova ležita na isti ravnini (X,Y). 
{{{
#!python
topExp = TopExp_Explorer()
    topExp.Init(oblika, TopAbs_VERTEX)

    # Vzamemo dve točki (two vertices)
    vertA = topods_Vertex(topExp.Current())
    topExp.Next()
    vertB = topods_Vertex(topExp.Current())
    anEdgeExplorer = TopExp_Explorer(oblika, TopAbs_EDGE)
    while anEdgeExplorer.More():
        edge = topods.Edge(anEdgeExplorer.Current())
        first, last = topexp_FirstVertex(edge), topexp_LastVertex(edge)
        vertex, first_vert, last_vert = BRep_Tool().Pnt(vertA), BRep_Tool().Pnt(first), BRep_Tool().Pnt(last)
        if first_vert.Z() != last_vert.Z():
            zaokrozitev.Add(Radij_1, edge)
        anEdgeExplorer.Next()
    afillet.Build()
    oblika = afillet.Shape()
}}}
Če želimo narediti zaokrožitev le na določenih robovih lahko s pomočjo TopExp_Explorer-ja ustvarimo seznam z vsemi robovi. Tako lahko potem izberemo željene robove in na njih izvedemo zaokrožitev.
{{{
#!python
anEdgeExplorer = TopExp_Explorer(izvlek, TopAbs_EDGE)
    results = []
    while anEdgeExplorer.More():
       anEdge = topods().Edge(anEdgeExplorer.Current())
       results.append(anEdge)
       anEdgeExplorer.Next()
    anEdgeExplorer.ReInit() 
zaokrozitev.Add(Radij, results[0])
zaokrozitev.Add(Radij, results[2])
.
.
.
}}}
Pri izdelavi zaokrožitev moramo biti pozorni na velikost zaokrožitve. Vrednost zaokrožitve mora biti dovolj majhna da lahko normalno zaokrožimo robove.
[[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]]


==== Zaokrožitev z variabilnim radiem zaokrožitve ==== 
[[Image(27.png, 300, right)]]
Za apliciranje variabilnega radija zaokrožitve na modelu je potrebno razdeliti izbrani rob na intervale ter nato določiti radij zaokrožitve na določenem intervalu. Primer razdelitve robu na 6 intervalov ter določitev parametrov:
{{{
#!python
TabPoint = TColgp_Array1OfPnt2d(1,6)
P1 = gp_Pnt2d(0.,8.)
P2 = gp_Pnt2d(0.2,16.)
P3 = gp_Pnt2d(0.4,25.)
P4 = gp_Pnt2d(0.6,55.)
P5 = gp_Pnt2d(0.8,28.)
P6 = gp_Pnt2d(1.,20.)
TabPoint.SetValue(1,P1)
TabPoint.SetValue(2,P2)
TabPoint.SetValue(3,P3)
TabPoint.SetValue(4,P4)
TabPoint.SetValue(5,P5)
TabPoint.SetValue(6,P6)
}}}
Določitev izbranega robu na katerem izvedemo ukaz poteka:
{{{
#!python
exp = TopExp_Explorer(Oblika,TopAbs_EDGE)
exp.Next()
exp.Next()
exp.Next()
exp.Next()
}}}


==== Zaokrožitev okoli točke ====
[[Image(28.png, 300, right)]]
Zaokrožitev lahko izvedemo tudi okoli točke. V tem primeru je potrebno najprej izbrati točko, okoli katere hočemo izvesti zaokrožitev. Nato določimo vse robove, ki imajo začetno ali končno vozlišče v izbrani točki, ter izvedemo zaokrožitev na teh robovih. To lahko naredimo z uvedbo nove funkcije:
{{{
#!python
def vertex_fillet(oblika, vert):
    afillet = BRepFilletAPI_MakeFillet(oblika)
    cnt = 0
    # Iz točk najdemo robove
    _map = TopTools_IndexedDataMapOfShapeListOfShape()
    topexp_MapShapesAndAncestors(oblika, TopAbs_VERTEX, TopAbs_EDGE, _map)
    results = _map.FindFromKey(vert)
    topology_iterator = TopTools_ListIteratorOfListOfShape(results)
    while topology_iterator.More():
        edge = topods_Edge(topology_iterator.Value())
        topology_iterator.Next()
        first, last = topexp_FirstVertex(edge), topexp_LastVertex(edge)
        vertex, first_vert, last_vert = BRep_Tool().Pnt(vert), BRep_Tool().Pnt(first), BRep_Tool().Pnt(last)
        if edge.Orientation():
            if not vertex.IsEqual(first_vert, 0.001):
                afillet.Add(0, 20., edge)
            else:
                afillet.Add(20, 0, edge)
        cnt += 1
    afillet.Build()
    if afillet.IsDone():
        return afillet.Shape()

#izvedba zaokrozitve okoli tocke
zaokrozitev_tocka = vertex_fillet(oblika,tocka1)
}}}
[[BR]][[BR]]


=== Izdelava posnetij (Chamfer) ===
[[Image(29.png,600, right)]]
Pri izdelavi posnetij v programskem okolju je potrebno predhodno uvesti knjižnico orodij za izdelavo posnetij:
{{{
#!python
from OCC.TopExp import* #knjiznica z topoloskimi elementi
from OCC.BRepFilletAPI import * #Knjiznica z zaokrozitvami
from OCC.Utils.Topology import *
from OCC.BRep import *
}}}
Izdelava posnetja poteka podobno, kakor izdelava zaokrožitve, saj imamo za vir ukazov isto knjižnico BRepFilletAPI. Na enak način, kot v primeru zaokrožitve, določimo uporabo posnetja:
{{{
#!python
posnetje = BRepFilletAPI_MakeChamfer(kocka.Shape())
}}}
Operacija za izdelavo posnetja pa zahteva nekoliko več argumentov, saj je lokacija posnetja določena z izbiro robu ter referenčne površine. Pri določitvi velikosti posnetja imamo lahko primer posnetja pod kotom 45°, za kar rabimo določiti samo eno razdaljo posnetja, ali pa primer ko imamo kot posnetja različen od 45°. V tem primeru je potrebno določiti razdalji posnetja na površinah, ki obdajata rob. Dodajanje posnetja na obliko poteka:
{{{
#!python
posnetje.Add(Razdalja, Rob, Povrsina)
posnetje.Add(Razdalja_1, Razdalja_2, Rob, Povrsina)
}}}
Primer izdelave posnetja na zgornji in spodnji ploskvi kocke:
{{{
#!python
posnetje = BRepFilletAPI_MakeChamfer(Oblika)
topology_traverser = Topo(Oblika)
for aEdge in topology_traverser.edges():
    first, last = TopExp().FirstVertex(aEdge), TopExp().LastVertex(aEdge)
    first_vert, last_vert = BRep_Tool().Pnt(first), BRep_Tool().Pnt(last)
    if first_vert.Z()==Visina and last_vert.Z()==Visina:
        for aFace in topology_traverser.faces():
                posnetje.Add(Razdalja, Rob, Povrsina)
#                posnetje.Add(Razdalja_1, Razdalja_2, Rob, Povrsina)
    if first_vert.Z()==0 and last_vert.Z()==0:
        for aFace in topology_traverser.faces():
                posnetje.Add(Razdalja, Rob, Povrsina)
#                posnetje.Add(Razdalja_1, Razdalja_2, Rob, Povrsina)
kocka = posnetje
}}}

=== Izdelava lupine ( Shell ) ===
[[Image(30.png, 600, right)]]
Volumski model lahko pretvorimo tudi v tenkostenski objekt z orodjem za izdelavo lupin. Pri tem uporabimo nabor ukazov iz knjižnice BRepOffsetAPI:
{{{
#!python
from OCC.BRepOffsetAPI import *
}}}
Pri izdelavi lupine je potrebno določiti geometrijo iz katere hočemo narediti lupiono, ploskve, ki jih hočemo odstraniti, debelino lupine ter toleranco izdelave modela:
{{{
#!python
lupina = BRepOffsetAPI_MakeThickSolid(Oblika, Odstr_ploskve, debelina, toleranca)
}}}
[[BR]][[BR]][[BR]][[BR]][[BR]][[BR]][[BR]]

=== Izdelava odmika ( OffsetShape ) ===
[[Image(31.png, 300, right)]]
Z orodjem za izdelavo odmika lahko napravimo nov objekt, ki bazira na obstoječi geometriji, le da je nekoliko večji ali pa manjši. Za uporabo ukaza je potrebno v program uvesti knjižnico:
{{{
#!python
from OCC.BRepOffsetAPI import *
}}}
Napravimo vzporedni odmik posamezne ploskve ali pa vzamemo kar celotni objekt. Najbolj preprosta operacija zahteva argumente geometrije, dolžine vzporednega odmika ter tolerace. Vzporedni odmik lahko poteka v obe smeri- lahko naredimo element, ki je večji ali manjši od osnovnega modela. 
{{{
#!python
odmik = BRepOffsetAPI_MakeOffsetShape(Oblika,debelina,toleranca)
odmik = BRepOffsetAPI_MakeOffsetShape(Oblika,debelina,toleranca, BRepOffset_Skin, Standard_False, Standard_False, GeomAbs_Intersection)
}}}
[[BR]][[BR]][[BR]][[BR]][[BR]]

=== Izdelava kota nagiba ( Draft_Angle ) ===
[[Image(32.png, 300, right)]]
Z ukazom modificiramo obstoječo geometrijo s tem, da dodamo nagibne kote na planarne, cilindrične ali konične ploskve na modelu. Uporabimo knjižnico ukazov BRepOffsetAPI. Uporabo ukaza določimo z:
{{{
#!python
nagib = BRepOffsetAPI_DraftAngle(oblika)
}}}
Pri tem je potrebno odločiti še parametre, kot so smer normale, kot nagiba v radianih ter nevtralno ravnino. Primer dodajanja kota nagiba na objekt:
{{{
#!python
nagib = BRepOffsetAPI_DraftAngle(Oblika)
for f in topo.faces():
    surf = Handle_Geom_Plane_DownCast(BRep_Tool_Surface(f)).GetObject()
    dirf = surf.Pln().Axis().Direction()
    ddd = gp_Dir(0,0,1)
    if dirf.IsNormal(ddd, Precision_Angular()):
        nagib.Add(f, ddd, math.radians(25), gp_Pln(gp_Ax3(gp_XOY())))
nagib.Build()
}}}
[[BR]][[BR]]

=== Izdelava rebra ( MakeLinerForm ) ===
[[Image(33.png, 300, right)]]
Za izdelavo ojačitvenega rebra med dvema planarnima površinama se uporabi ukaz BRepFeat. Za izvedbo ukaza je potrebno vključiti naslednjo knjižnico:
{{{
#!python
from OCC.BRepFeat import *
from OCC.BRepAlgoAPI import *
}}}
Pri izdelavi rebra je potrebno imeti najprej že predhodno narejen model, ki vsebuje dve povšini, med katerima lahko napravimo rebro. Izdelava rebra poteka v parih preprostih korakih. Najprej je potrebno napraviti črto, ki povezuje obe površini. To naredimo tako, da določimo dve točki, ki se nahajata vsaka na eni izmed površin. Nato naredimo referenčno ravnino, ki služi kot referenca za prerez rebra:
{{{
#!python
Povezava = BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeEdge(Tocka_1, Tocka_2).Edge() )
ravnina = Geom_Plane(U_X,U_Y,U_Z, odmik_v_smeri)
}}}
Za izdelavo rebra uporabimo ukaz MakeLinearForm, kjer uporabimo poznano obliko, povezavo med površinama, referenčno ravnino, ter dva vektorja, ki nam določita smer oziroma debelino rebra v eni ter v drugi smeri glede na normalo ravnine:
{{{
#!python
Vect_1 = gp_Vec(0.,0.,5.) # odmik v eno smer glede na ravnini
Vect_2 = gp_Vec(0.,0.,-5.) # odmik v drugo smer glede na ravnino
z_rebrom = BRepFeat_MakeLinearForm( Oblika.Shape(), Povezava.Wire(), ravnina.GetHandle(),Vect_1, Vect_2, 1, True )
}}}
[[BR]][[BR]]

=== Zrcaljenje ( Mirror ) ===
Za zrcaljenje poljubne oblike se uporabi ukaz iz knjižnice BRepBuilderAPI:
{{{
#!python
from OCC.BRepBuilderAPI import *
}}}
Pri zrcaljenju objekta preko točke je potrebno najprej definirati točko zrcaljenja ter nato določiti izbrano točko za zrcaljenje:
{{{
#!python
Transformacija = gp_Trsf()
Tocka_zrcaljenja = gp_Pnt(110.,60.,60.)
Vozlisce = BRepBuilderAPI_MakeVertex(Tocka_zrcaljenja)	
Transformacija.SetMirror(Tocka_zrcaljenja);
}}}
Za izvedbo zrcaljenja uporabimo ukaz BRepBuilderAPI_Transform, kjer v prvem argumentu določimo objekt ki ga zrcalimo, v drugem argumentu pa transformacijsko obliko, ki že vsebuje podatek o tipu transformacije ter parametre.
{{{
#!python
myBRepTransformation = BRepBuilderAPI_Transform(Prizma,Transformacija)
Zrcalna_oblika = myBRepTransformation.Shape()
}}}
[[BR]][[BR]]

== Izvoz/ uvoz modelov različnih formatov ==

Z odprtokodnim modelirnim jedrom OpenCascade je možno tudi uvoziti in izvoziti modele različnih formatov. Izmenjava datotek med različnimi modelirniki je problematična tematika, zato obstajajo standradni formati zapisa modelov, ki jih je možno vpeljati v različne modelirnike. Opisani so postopki, ki nam pomagajo pri prikazu modelov, narejenih v različnih zapisih.

=== Izvoz modelov ===
[[Image(34.png, 300, right)]]
Izdelani objekt, narejen z OpenCasade jedrom, lahko izvozimo v več pojubnih formatov. Za to imamo na voljo knjižnice za izvoze v različne datoteke.
[[BR]][[BR]]
Izvoz v STEP
[[BR]][[BR]]
Za izvoz objekta v STEP format imamo na voljo knjižnico DataExchange.STEP:
{{{
#!python
from OCC.Utils.DataExchange.STEP import STEPExporter
}}}
Model izvozimo v format STEP tako, da najprej določimo ime novonastale datoteke, nato pa ime objekta, ki ga izvozimo:
{{{
#!python
def Izvoz_v_STEP(event=None):
    izvoz_v_STEP = STEPExporter("Model_STEP.stp")
    izvoz_v_STEP.add_shape(oblika)
    izvoz_v_STEP.write_file()
}}}
[[BR]][[BR]]
Izvoz v STL
[[BR]][[BR]]
Za izvoz objekta v STL format imamo na voljo knjižnico StlApi:
{{{
#!python
from OCC.StlAPI import *
}}}
Model izvozimo v format STL tako, da najprej določimo ime novonastale datoteke, nato pa ime objekta, ki ga izvozimo:
{{{
#!python
def Izvoz_v_STL(event=None):
    izvoz_v_STL = StlAPI()
    izvoz_v_STL.Write(oblika, "Model_STL.stl", False)
}}}

=== Uvoz modelov ===
[[Image(35.png, 300, right)]]
Izdelani objekt, shranjen v formatu STEP, IGES ali STL, lahko prikažemo tudi v OpenCascade-u. Za to imamo na voljo knjižnice za uvoze iz različnih datotek.
[[BR]][[BR]]
Uvoz iz IGES
[[BR]][[BR]]
Za uvoz objekta iz IGES format imamo na voljo knjižnico DataExchange.IGES:
{{{
#!python
from OCC.Utils.DataExchange.IGES import IGESImporter
}}}
Model iz IGES formata uvozimo tako, da najprej določimo ime datoteke, nato datoteko preberemo, na koncu pa model prikažemo:
{{{
#!python
def Uvoz_iz_IGES(event=None):
    uvoz_iz_IGES = IGESImporter("primer_iges.igs")
    uvoz_iz_IGES.read_file()
    oblika = uvoz_iz_IGES.get_shapes()
    display.EraseAll()
    display.DisplayShape(oblika)
}}}
[[BR]][[BR]]
Uvoz iz STEP
[[BR]][[BR]]
Za uvoz objekta iz STEP format imamo na voljo knjižnico DataExchange.STEP:
{{{
#!python
from OCC.Utils.DataExchange.STEP importSTEPImporter
}}}
Model iz STEP formata uvozimo tako, da najprej določimo ime datoteke, nato datoteko preberemo, na koncu pa model prikažemo:
{{{
#!python
def Uvoz_iz_STEP(event=None):
    uvoz_iz_STEP = STEPImporter("primer_step.stp")
    uvoz_iz_STEP.read_file()
    oblika = uvoz_iz_STEP.get_shapes()
    display.EraseAll()
    display.DisplayShape(oblika)
}}}
[[BR]][[BR]]
Uvoz iz STL
[[BR]][[BR]]
Za uvoz objekta iz STL format imamo na voljo knjižnico StlAPI:
{{{
#!python
from OCC.StlAPI import *
}}}
Model iz STL formata uvozimo tako, da najprej določimo ime datoteke, nato datoteko preberemo, na koncu pa model prikažemo:
{{{
#!python
def Uvoz_iz_STL(event=None):
    oblika = TopoDS_Shape()
    uvoz_iz_STL = StlAPI()
    uvoz_iz_STL.Read(oblika, "Model_STL.stl")
    display.EraseAll()
    display.DisplayShape(oblika)

}}}