これはFreeCADのマニュアルです。FreeCADドキュメンテーションWikiの要点が記載されています。このマニュアルは基本的には一つの大きなドキュメントとして印刷するために作成されています。オンラインで読む場合にはブラウジングしやすいオンラインヘルプ版を直接使った方がいいかもしれません。

FreeCADオンラインヘルプへようこそ

このドキュメントはオンラインで読むことができる公式FreeCADウィキドキュメント http://apps.sourceforge.net/mediawiki/free-cad/index.php?title=Main_Page/jp の内容から自動で作成されたものです。ウィキは活発にメンテナンスされていますし、開発者とユーザーによって作られているFreeCADコミュニティーによって絶え間なく加筆されているのでこのドキュメントよりもオンライン版の方がより多く、より新しい情報が記載されている可能性があります。またオンライン版ではこのドキュメントの進行中の多言語翻訳を読むこともできます。とは言っても私たちはここで必要な情報全てが見つけられるようにしたいと考えています。このドキュメントであなたの疑問に対する回答を見つけることができなかった場合はFreeCADフォーラムを見てください。答えがあるかもしれませんし、あるいは誰かが手助けしてくれるかもしれません。

使用方法

このドキュメントはイントロダクション、使用方法、スクリプト処理、開発という四つのセクションに分けられています。後半の三つはFreeCADのユーザーの三つの大きな分類に対応しています。たんにプログラムを使いたいだけのエンドユーザー、FreeCADのスクリプト処理機能に興味があってFreeCADの機能のカスタマイズを行いたいと思っているパワーユーザー、そして自分のアプリケーションの開発基盤としてFreeCADを考えている開発者です。もしあなたが今まで全くFreeCADに触れたことがないのであれば深く考えずにイントロダクションから読み始めることをお勧めします。

支援

あなたはプログラマーの書いたひどいヘルプを読んだ経験があるかもしれません。彼らにとってはプログラムの使い方は完璧に明らかです。何しろ作ったのは自分なのですから。つまり経験を積んだユーザーがドキュメントの作成や修正を手伝ってくれることが必要不可欠なのです。そう、あなたのことです！やり方がわかりませんか？まずUserセクションに記載された http://apps.sourceforge.net/mediawiki/free-cad/index.php にあるウィキに行ってください。ログインにはSourceforgeのアカウントが必要です。ログインしたらフォーラムかIRCチャンネルで書き込み権限をくれるように依頼してください（スパム防止のためにウィキには書き込み保護がかかっています）。書き込み権限を手に入れたら編集ができるようになります！またHelp_FreeCADページも見てください。さらに多くのFreeCADを支援するための方法が記載されています。

はじめに

FreeCADのインターフェース

FreeCAD は汎用の3DCAD モデラーです。完全なオープンソース（GPL＆LGPLライセンス）で開発されています。FreeCADは機械工学と製品設計向けですが、それだけではなく建築やその他の専門工学などの幅広い用途にも適しています。

FreeCADはCATIAやSolidWorks，Solid Edgeと類似のツールを備えているため、同様にMCAD やPLM 、CAx やCAE のカテゴリーに属します。 FreeCADはフィーチャーベースのパラメトリックモデラーであり、システムのコアを改変することなく機能追加が簡単に行えるモジュラーソフトウェアアーキテクチャーを採用しています。

多くの現代的な3DCADモデラーと同様に、FreeCADも3Dモデルから詳細設計を抽出して2Dの製品図面を作成する2Dコンポーネントを備えています。ただしAutoCAD LTのようなダイレクトな2Dの作図をFreeCADは対象としません。これはアニメーションや有機的な形状(Mayaや3ds Max、Cinema 4Dのような）についても同様です。しかしながら、その広い適用能力のおかげでFreeCADは今よりもさらに多くの分野で使用できるようになることでしょう。

FreeCADのもうひとつの主要な関心事は科学計算分野で現存する全ての偉大なオープンソースライブラリをたっぷりと使用することです。その中には強力なCADカーネルであるOpenCascade、OpenInventor実装の一つであるCoin3D、世界的に有名なUIフレームワークであるQt、そして現存する最高のスクリプト言語の一つであるPythonが含まれます。またFreeCAD自身もライブラリとして他のプログラムから使用できます。

また、FreeCADは完全なクロスプラットフォームです。現在、Windows、Linux/Unix、Mac OSXシステムの全てのプラットフォーム上で完全に同じ様に動作します。

FreeCADの機能についてもっと知りたければ機能のリスト、最新のリリースノート、スタートガイドを見てください。すぐにユーザーハブを見に行くのもいいでしょう！

以下はFreeCADに実装されている多くの機能のリストです。ただし機能が多いため全てが記載されているわけではありません。もし将来的な計画について知りたいのであれば開発ロードマップを見てください。機能を概観したいのであればスクリーンショットを見るとよいでしょう。

リリースノート

• リリース 0.11

一般的な機能

基本アプリケーション

• FreeCADはマルチプラットフォームです。WIndows、Linux、Mac OSXで完全に同じように動作します。

• FreeCADは完全なGUIアプリケーションです。FreeCADは完全なグラフィカルユーザーインターフェースを持っています。このグラフィカルユーザーインターフェースはよく知られるQtフレームワークを基盤にしており、3DビューワーはOpen Inventorを元に作成されています。これによって高速な3Dシーン描画が可能になり、シーンのグラフィック表現の取り扱いが非常に容易になっています。

• FreeCADはコマンドラインアプリケーションとしても動作します。この場合にはメモリーの消費量を低くすることができます。コマンドラインモードでのFreeCADはインターフェイス無しで実行されますが、全てのジオメトリツールを使用することができます。これによって例えば他のアプリケーション用のデータを作成するためのサーバーとしてFreeCADを使用することが可能になります。

• FreeCADはPythonモジュールとしてインポートすることができます。pythonスクリプトを実行できる他のアプリケーション内部、あるいはpythonコンソールへインポート可能です。コンソールモードの場合と同様、FreeCADのインターフェイス部分を使用することはできませんが、全てのジオメトリツールを使用することができます。

• 機能/データタイプの遅延読み込みのためのプラグイン/モジュールフレームワーク。FreeCADはコアアプリケーションと必要な場合にのみロードされるモジュールに分割されています。ほとんど全てのツールとジオメトリータイプはモジュールとして保持されています。モジュールはプラグインのように動作し、既にインストールされたFreeCADに対して追加したり削除したりすることが可能です。

• 組み込みのスクリプトフレームワーク: FreeCADにはPythonインタープリターが組み込まれています。またアプリケーション、インターフェイス、ジオメトリー、3Dビューワー上のジオメトリー表現のほとんど全てを網羅したAPIを兼ね備えています。インタープリターは1つのコマンドから複雑なスクリプトまで実行でき、実質的には全モジュールを完全にPythonでプログラムすることさえ可能です。

• モジュール化されたMSIインストーラーによってWindowsシステム上への柔軟なインストールが可能です。Ubuntuシステム用のパッケージも整備されています。

ドキュメント構造

• アンドゥ/リドゥフレームワーク: アンドゥスタックにアスセスすることで全ての操作をアンドゥ/リドゥ可能です。一度に複数のステップをアンドゥすることができます。

• トランザクションマネージメント: アンドゥ/リドゥスタックは一つのアクションではなくドキュメントのトランザクションを保持します。これによって各ツールは何をアンドゥまたはリドゥするかを正確に定義することができます。

• パラメーター連想ドキュメントオブジェクト: FreeCADドキュメント上のオブジェクトは全てパラメーターによって定義することが可能です。このパラメーターは動的に変更することが可能でいつでも再計算を行えます。オブジェクトの間の関連付けを保持することも可能なので一つのオブジェクトを変更するとそれに依存したオブジェクトも変更されます。

• （ZIPベースの）複合ドキュメント保存フォーマット: FreeCADドキュメントは.fcstd拡張子で保存できます。これにはジオメトリー、スクリプト、サムネイルアイコンといったさまざまな種類の情報を保存することができます。

ユーザーインターフェイス

• 完全にカスタマイズ/スクリプト化可能なグラフィカルユーザーインターフェース。

QtベースのFreeCADのインターフェイスに対してはPythonインタープリターを介した完全なアクセスが可能です。FreeCAD自体がワークベンチに提供する単純な機能だけではなく、Qtフレームワーク全体にアクセスできます。これによってウィジットとツールバーに対して作成、追加、ドッキング、削除といった任意のGUI操作を行うことができます。

• ワークベンチというコンセプト: FreeCADのインターフェイスではツールはワークベンチによってグループ分けされます。これによってある作業を行うために必要なツールだけを表示し、作業スペースを整頓された使いやすい状態に保ち、アプリケーションの読み込みを高速にすることができます。

• 組み込みのPythonコンソールには構文ハイライト機能、自動補完機能、クラスブラウザーが備わっています。Pythonコマンドは直接FreeCADに発行され、結果は直ちに返されます。これによってスクリプト作成者は動的に機能をテストすることができ、モジュールの中身を調べてFreeCADの内部構造を簡単に学ぶことができます。

• コンソール上でのユーザー操作のミラーリング: ユーザーがFreeCADのインターフェイスを介して行った操作はPythonのコードによって実行できます。このPythonのコードはコンソール上に表示したり、マクロとして記録することができます。

• 完全なマクロ記録と編集: ユーザーがインターフェイスを操作するとPythonコマンドが発行され、必要な場合はそれを記録、編集して後で再現するために保存することができます。

• サムネイラー (今のところLinuxシステムのみ): GnomeのNautilusを始めとしたほとんどのファイルマネージャーアプリケーションでFreeCAD ドキュメントのアイコン上にファイルの内容を表示します。

アプリケーション固有の機能

FreeCADの機能はモジュールに分割されています。それぞれのモジュールは固有のデータタイプとアプリケーションを扱います:

メッシュ

• メッシュモジュールは3Dメッシュを扱います。主にサードパーティが作成したメッシュジオメトリーをFreeCADにインポートし、修正し、変換してエクスポートすることを目的としています。ただしFreeCAD自体にもメッシュに留まらないより高度なジオメトリータイプが備わっています。

• プリミティブの作成（直方体、球、円筒など）、オフセット (trivial or after Jung/Shin/Choi)、ブーリアン演算 (加算, 切断、交差)

• インポート 以下の形式をインポート可能: ASCII・バイナリのSTL (Stereo lithography format) (*.stl, *.ast)、OBJ format (*.obj)、NASTRANを一部サポート (*.nas)、Open Inventorメッシュ (*.iv)、FreeCADのネイティブメッシュカーネル (*.bms)

• エクスポート 以下の形式をエクスポート可能: ASCII・バイナリのSTL (Stereo lithography format) (*.stl, *.ast)、OBJ format (*.obj)、NASTRANを一部サポート (*.nas, *.brl)、VRMLメッシュ (*.wrl)、FreeCADのネイティブメッシュカーネル (*.bms)、Pythonモジュールとしてのメッシュ (*.py)

• テストと修正をメッシュに行うためのツール: ソリッドかどうかのテスト、非2次元多様体かどうかのテスト、自己交差しているかどうかのテスト、穴埋めと向きの統一。

• たくさんの PythonスクリプトAPI。

2D製図

• 3D空間内の任意の面上でのライン、ワイヤー、長方形、円弧、円などの単純な平面ジオメトリーのグラフィカルな作成

• 文字や数字での注釈

• 3D空間内の任意の面上での移動、回転、拡大縮小、鏡像反転、オフセット、形状変換といったグラフィカルな変更操作

• インポートとエクスポート 以下の形式をサポート: AutodeskのDrawing Exchange Format (*.dxf)、Open Cad Format (*.oca, *.gcad)、SVG (*.svg)

CAD

• パートモジュールはCADモデリングとCADデータ構造に関係した全てを扱います。CAD機能はとりわけ注力して開発が行われています（開発ロードマップのパート設計プロジェクトとアセンブリプロジェクトを参照してください）。 パートモジュールは高レベルのOpen CASCADEジオメトリーを使用しています。

• パラメトリックなプリミティブ形状 直方体、球、円筒、円錐、トーラスなど

• 頂点、辺、ワイヤーまた面といった幾何形状部品 （Pythonスクリプト経由）

• 直線、曲線の押し出し、分割、フィレットによるモデリング

• ブーリアン演算 和集合、差集合、共通集合など

• たくさんのPythonスクリプトAPI。

• インポートとエクスポート 以下の形式をサポート: STEP パーツとアセンブリ (*.stp,*.step)、IGESモジュール (*.igs, *.iges) とBRep (*.brp)、私たちが使っているOpen CASCADE CADカーネルのネイティブフォーマット。

レイトレーシング

• レイトレーシングモジュールを使うとFreeCAD上のジオメトリーをエクスポートして高品質な画像作成するための外部のレンダリングソフトウェアで使うことができます。今のところサポートしているレンダリングエンジンはPOV-Rayだけです。現在のところこのモジュールはレンダーシートを作成し、POV-Rayファイルにエクスポートするためにジオメトリーをレンダーシートに追加することができます。

図化

• 図化モジュールでは3Dジオメトリーの投影図を2D SVGドキュメントとしてエクスポートすることができます。このモジュールでは既存のSVGテンプレートを使った2Dシートとそのシートに対するジオメトリーの投影図を作成することができます。作成したシートはSVGファイルとして保存可能です。

CAM

• CAMモジュールはスライス加工など機械加工のために用意されています。このモジュールはまだ開発が始まったばかりで、今のところインクリメンタルなシート成形にもっとも力が注がれています。他にもいくつかの工具経路計画アルゴリズムがありますが今のところはエンドユーザーが使えるようにはなっていません。

インストール

Windows上でのインストール

Windows上でのFreeCADのインストールのもっとも簡単なやり方は下記のインストーラーをダウンロードすることです。
Windows 32 bits

Windows 64 bits

.msi (Microsoftインストーラー)ファイルをダウンロードし、それをダブルクリックするだけでインストール処理が開始します。

以下には技術的なオプションのより詳しい情報が記載されています。よくわからなくても心配は無用です！ほとんどのWindowsユーザーはインストール用.msiで行うこと以上のことは必要ありません。 さあ始めましょう！

シンプルなMicrosoftインストーラーでのインストール

Windows上でのFreeCADのインストールのもっとも簡単なやり方は上記のインストーラーを使う方法です。このページでは追加のインストールオプションを使ったMicrosoftインストーラーの機能とその使い方を説明します。

もし64ビット版や不安定開発版をダウンロードしたければダウンロードページを見てください。

コマンドラインでのインストール

msiexec.exeコマンドラインユーティリティーを使用すると非対話的なインストールや管理者用インストールといった追加機能を使用することができます。

非対話的なインストール

以下のコマンドを使用するとインストールをプログラム的に開始させることが可能です。

 msiexec /i FreeCAD<version>.msi

追加パラメーターは以下のようにコマンドラインの末尾で設定できます。

 msiexec /i FreeCAD-2.5.msi TARGETDIR=r:\FreeCAD25

制限付きユーザーインターフェイス

/qオプションを使うことでインストーラーが表示するインターフェイスの量をコントロールできます。具体的には以下の通りです：

• /qn - インターフェイス無し
• /qb - 簡易インターフェイス - 小さなプログレスダイアログだけです
• /qb! - /qbと同じですがキャンセルボタンを非表示にします
• /qr - 省略インターフェイス - 全てのダイアログを表示しますがユーザー操作は必要とされません（モーダルダイアログは全てスキップされます）
• /qn+ - /qnと同じですが、最後に"Completed"ダイアログが表示されます
• /qb+ - /qbと同じですが、最後に"Completed"ダイアログが表示されます

ターゲットディレクトリ

TARGETDIRプロパティによってFreeCADインストール先のルートディレクトリを設定できます。例えば以下のようにすると異なるインストールドライブを指定できます。

TARGETDIR=R:\FreeCAD25

デフォルトのTARGETDIRは[WindowsVolume\Programm Files\]FreeCAD<version>です。

全てのユーザーにインストール

 ALLUSERS=1

を追加すると全てのユーザーにインストールを行います。非対話的なインストールはデフォルトではカレントユーザーにのみパッケージをインストールします。また対話的なインストールはユーザーが必要な権限を持っている場合にデフォルトが"all users"のダイアログを表示します。

機能の選択

複数のプロパティを使用してインストールされる機能、再インストールされる機能、削除される機能を選択することができます。FreeCADでの機能のセットは以下の通りです。

• DefaultFeature - ソフトウェア一式とコアライブラリーをインストールします
• Documentation - ドキュメントをインストールします
• Source code - ソースコードをインストールします
• ... ToDo

さらにALLで全ての機能を指定できます。全ての機能はDefaultFeatureに依存するのでどれか一つでも機能を自動でインストールするとはDefaultFeatureでインストールされる機能もインストールされます。以下のプロパティを使うとインストールされる機能、削除される機能をコントロールできます。

• ADDLOCAL - ローカルマシン上にインストールされる機能のリスト
• REMOVE - 削除する機能のリスト
• ADDDEFAULT - デフォルト設定に追加される機能のリスト（FreeCADの全機能の一部）
• REINSTALL - 再インストール/修復される機能のリスト
• ADVERTISE - アド表示インストールが行われる機能のリスト

さらにいくつかのプロパティが利用可能です。詳細についてはMSDNのドキュメントを見てください。

これらのオプションに加えて

 ADDLOCAL=Extensions

を追加した場合、インタープリター自体のインストールと拡張子の登録が行われ、他には何もインストールされません。

アンインストール

 msiexec /x FreeCAD<version>.msi

とするとFreeCADをアンインストールできます。パッケージまたはプロダクトコードを代わりに指定すればアンインストール用のMSIファイルは必要ありません。プロダクトコードはFreeCADがスタートメニューにインストールするアンインストール用ショートカットのプロパティで確認できます。

管理者用インストール

 msiexec /a FreeCAD<version>.msi

とすると"管理者用"（ネットワーク）インストールを開始できます。ファイルがターゲットディレクトリ（ネットワークディレクトリである必要があります）に展開されますがローカルマシンに対してはそれ以外の変更は行われません。また別の（小さな）msiファイルがターゲットディレクトリに生成され、クライアントはそれを使ってローカルへのインストールを行うことができます（将来的なバージョンではいくつかの機能を完全にネットワークドライブ上に置くことができるようになる予定です）。

今のところ、管理者用インストールにはユーザーインターフェイスが無いのでターゲットディレクトリはコマンドラインで渡す必要があります。

管理者用インストールには特にアンインストール手順はありません - クライアントが使用しなくなった場合はターゲットディレクトリを削除するだけで問題ありません。

アドバタイズのインストール

 msiexec /jm FreeCAD<version>.msi

とするとFreeCADをマシンに"アドバタイズ"することができます（/juでユーザーにアドバタイズできます）。これを行うと実際にソフトウェアをインストールすることなくスタートメニューにアイコンを表示し、拡張子を登録することができます。機能の実際のインストールはその機能を初めて使用する時になって行われます。

FreeCADインストーラーでは今のところスタートメニューでのアドバタイズのみサポートし、ショートカットでのアドバタイズはサポートしていません。

マシングループへの自動インストール

Windowsグループポリシーを使うとマシングループに自動でFreeCADをインストールすることが可能です。実行には以下のステップを行なってください。

1. ドメインのコントローラーにログオンします
2. 全てのターゲットマシンからアクセスできる共有フォルダにMSIファイルをコピーします
3. MMCスナップインの"Active Directory ユーザーとコンピュータ"をを開きます
4. FreeCADをインストールするコンピューターグループに移動します
5. プロパティを開きます
6. グループポリシーを開きます
7. 新しいポリシーを追加し、編集します
8. コンピュータの構成/ソフトウェアインストールで新規作成/パッケージを選択します
9. ネットワークパスからMSIファイルを選択します
10. オプションでコンピューターがポリシーの範囲を外れた場合にFreeCADがアンインストールされるようにすることができます

グループポリシーが伝達されるまでには普通、多少の時間がかかります - 確実にパッケージを配置するには全てのマシンを再起動する必要があります。

CrossoverOfficeを使用したLinuxへのインストール

CXOffice 5.0.1を使うとWindows版のFreeCADをLinuxシステム上にインストールできます。CXOfficeのコマンドラインからmsiexecを実行してください。インストールパッケージはドライブレター"Y:"にマップされた"software"ディレクトリに配置されます：

msiexec /i Y:\\software\\FreeCAD<version>.msi

FreeCADは実行されますがOpenGL表示が動作しないことが報告されています。これはGoogle SketchUpなどWine上で動作するプログラム全般に言えることです。

Linux/Unix上でのインストール

ほとんどの有名なLinuxシステム上でFreeCADのインストールが可能なことがコミュニティーによって確かめられています。またあなたのディストリビューションで使用できるパッケージマネージャーでも直接FreeCADを利用できるはずです。FreeCADチームは新しいリリースが作成されるタイミングでいくつかの"公式"パッケージと最先端機能のテスト用の実験的PPAリポジトリを提供しています。

FreeCADのインストールが終るといよいよ使い始めることができます！

Ubuntu

FreeCADはVersion 9.04移行のUbuntuリポジトリから利用することができ、ソフトウェアセンターまたは以下のコマンドでインストールできます：

sudo apt-get install freecad

またFreeCADコミュニティーはデイリービルドを行なっているPPAを提供しています。毎日、最新のソースコードから自動ビルドが行われ、このPPAが更新されています。従ってこれには最大でも一日遅れで最新機能が取り込まれますが同時にリグレッション（機能上の不具合）が含まれている可能性もあります。このPPAをあなたのソフトウェアソースリストに追加するには以下を行なってください：

sudo add-apt-repository ppa:freecad-maintainers/freecad-daily
sudo apt-get update
sudo apt-get install freecad

FreeCADコミュニティーはこれ以外にももう一つPPAを提供しています。こちらはもっと長い間隔で手動更新されているのでより安全です：

sudo add-apt-repository ppa:freecad-maintainers/freecad-dev
sudo apt-get update
sudo apt-get install freecad

詳細についてはDownload#Ubuntu_PPA_packagesページを見てください。

Debian、Mint、その他のDebianベースのシステム

Debian Lenny以降ではDebianソフトウェアレポジトリーから直接FreeCADが利用可能です。Synapticまたは以下のコマンドでインストールできます：

sudo apt-get install freecad

OpenSUSE

以下のコマンドでFreeCADのインストールができます：

zypper install FreeCAD

Gentoo

以下のコマンドでFreeCADのビルド/インストールができます：

emerge freecad

その他

もしあなたのシステムでFreeCADが動くにもかかわらずこのページにドキュメントがない場合はフォーラムで私たちに教えてください！

またこれ以外にも多くの非公式なFreeCADパッケージがネット上で利用可能です。例えばSlackwareやFedoraといったシステム用のものです。ネットを検索すればすぐに見つかるでしょう。

.debベースのシステムへの手動インストール

もし何らかの理由で上記の方法が使えない場合はいつでもダウンロードページから.debパッケージをダウンロードすることができます。
Ubuntu 32/64bit AppImage 64bit

まずあなたのシステムに対応した.debをダウンロードします。あなたのシステムにGdebiパッケージがインストールされている場合（通常はされています）、ファイルをダウンロードした場所に移動してファイルをダブルクリックします。必要な依存関係はシステムのパッケージマネージャーが自動で解決してくれます。 またターミナルからインストールすることもできます。ファイルをダウンロードした場所に移動して以下のように入力してください：

sudo dpkg -i Name_of_your_FreeCAD_package.deb

Name_of_your_FreeCAD_package.debはダウンロードしたファイルの名前に変えてください。

FreeCADのインストールが済むとStart Menuの"Graphic"セクションにスタートアップアイコンが追加されます。

その他のLinux/Unixシステムへのインストール

残念なが今のところ他のLinux/Unix用の利用可能なコンパイル済みパッケージはありません。自分でFreeCADをコンパイルする必要があります。

Windows版のLinuxへのインストール

Windows上でのインストールページを参照してください。

Mac上でのインストール

インストーラーを使って1ステップでFreeCADをMac OS Xにインストールすることができます。
Mac 10.9 Mavericks 64-bit
このページではFreeCADインストーラーの使い方と機能を説明しています。またアンインストール方法も記載されています。 インストールが終わると使い始めることができます！

簡単なインストール

FreeCADインストーラーはディスクイメージファイルに収められたインストールパッケージ（.mpkg）として提供されています。

最新のインストーラーはダウンロードページからダウンロードすることができます。ファイルをダウンロードしたらディスクイメージをマウントしてInstall FreeCADパッケージを実行してください。

インストールされるパッケージのリストが記載されたCustomize Installation画面をインストーラーが表示します。もし既にこれらのパッケージのどれかがインストールされている場合はチェックボックスを使ってインストール選択を外すことができます。インストールされているかどうかわからない場合は全てのアイテムにチェックをいれたままにしておいてください。

アンインストール

今のところFreeCADにはアンインストーラーがありません。FreeCADとインストールされた全てのコンポーネントを完全に取り除きたい場合は以下のファイルとフォルダをごみ箱にドラッグしてください。

• /Applications内：
  • FreeCAD

• /Library/Frameworks/内：
  • SoQt.framework
  • Inventor.framework

またターミナルから以下を実行してください：

sudo /Developer/Tools/uninstall-qt.py
sudo rm -R /usr/local/lib/OCC
sudo rm -R /usr/local/include/OCC

これで終わりです。FreeCADは最終的には自己完結型のアプリケーションバンドルとして利用できるようになる予定です。そうなればこれらの煩わしい作業も全てなくなるでしょう。

FreeCADを発見

新着情報

• バージョン0.12リリースノート ： FreeCAD リリース 0.12 の新着情報をチェックしてください。

序文

FreeCADは、CAD/CAE用のパラメトリックモデリングアプリケーションです。まだ開発の初期段階なので、すぐに作品の製作に使用できると期待しないように。でもFreeCADがどういったもので、またどういった機能が開発されているのか興味がある方は、是非ダウンロードして試してみてください。現時点では既にたくさんの機能が実装されています。しかしユーザーインターフェイスはまだ十分に開発されていません。したがって、もしあなたがPythonを少し知っていれば、比較的に簡単に複雑な形状の作成や修正にすぐに取りかかれますが、Pyhtonを知らなければ、FreeCADが提供する機能はまだほんの僅かであると感じるでしょう。でも待ってください、すぐに改善されますから。

評価後のアイデアや意見は、是非FreeCADディスカッションフォーラムで私たちと共有しましょう！

インストール

まず初めに（まだ済んでいなければですが）FreeCADをダウンロードしてインストールしてください。ダウンロードページで現在のバージョンと更新を確認しましょう。インストールパッケージはWindows用（.msi）とUbuntuとDebian用（.deb）、openSUSE（rpm）とMac OSX用を用意しています。 See the インストール page for information about how to install FreeCAD.

FreeCADを試してみる

最初に起動するFreeCADインターフェイスです。他のスクリーンショットも参照してください。

FreeCADは汎用の3Dモデリングアプリケーションです。機械工学と、専門的なエンジニアリングや建築などの関連分野に重点を置いています。FreeCADは、限られた特定のタスクを実行するためだけではなく、あらゆる種類の3Dアプリケーションを開発するためのプラットフォームとして考えられています。このため、FreeCADのインターフェイスは一連の ワークベンチに分けられています。ワークベンチでは特定のタスクやタスクグループに必要なツールのみを表示するようにインターフェイスの内容を変更することができます。

つまりFreeCADのインターフェイスは、メニューバーや3Dビュー領域、及びシーンの内容やオブジェクトのプロパティを表示するための幾つかのサイドパネルを持つ、とてもシンプルな容れ物であると言えるでしょう。また、これらのパネルの全ての内容はワークベンチに応じて変更することができます。

初めてFreeCAD起動すると"一般的な"ワークベンチ（我々は”完全なワークベンチ”と呼びますが）が表示されます。このワークベンチは、他のワークベンチから最も完成されたツールを集めたものです。FreeCADはかなり若くまだ専門的な作業には使用されていませんから、このワークベンチはFreeCADをより簡単に知るうえでとても役に立つでしょう。基本的には、ジオメトリを作成するために十分なツールは全てこのワークスペースにあります。

3次元空間での操作

FreeCADは2つの異なる操作モードを持っており、ユーザー設定ダイアログまたは3Dビューでの右クリックで変更できます。これらのモードの詳細についてはマウスモデルのページを見てください。 デフォルトのモード("CAD操作モード")ではコマンドは以下の通りです。

選択	平行移動	拡大縮小	回転表示
選択したいオブジェクトの上で左マウスボタンを押してください。Ctrlを押したまま操作すると複数のオブジェクトを選択できます。	マウス中央ボタンを押して動かしてオブジェクトを平行移動させます。	拡大縮小にはマウスホイールを使用してください。	まず中央マウスボタンを押し、そのまま表示されているオブジェクトの任意の点で左ボタンをクリックして好きな方向にドラッグします。こうすると中心の周りを回転する球のように回転が行われます。ドラッグを止める前にボタンを離すとオブジェクトは回転し続けます（有効になっている場合）。オブジェクト上の任意の点でマウスの中央ボタンをダブルクリックするとその点が回転、拡大縮小の原点に設定されます。

またViewメニュー、Viewツールバー、数値のショートカット（ 1 2など...）からプリセットのビュー（トップビュー、フロントビューなど）が利用できます。

2次元の製図

===作図オブジェクト===

オブジェクトを作成するためのツールです。

3Dパーツの作成

プリミティブ

プリミティブオブジェクトを作成するためのツールです。

• ボックス: 寸法を指定してボックスを描きます
• 円錐: 寸法を指定して円錐を描きます
• 円筒: 寸法を指定して円筒を描きます
• 球: 寸法を指定して球を描きます
• トーラス: 寸法を指定してトーラス（円環）を描きます

オブジェクトの変更

既存のオブジェクトを変更するためのツールです。変更するオブジェクトを選択して使用します。

• ブーリアン: オブジェクトのブーリアン演算を行います
• 結合: 二つのオブジェクトを結合します（和集合）
• 共通部: 二つのオブジェクトの共通部分を抽出します（共通集合）
• 切り取り: オブジェクトを別のオブジェクトから切り取ります（減算）
• 押し出し: オブジェクトの平面を押し出します
• フィレット: オブジェクトのエッジをフィレット処理（丸め処理）します
• 回転体: 別のオブジェクトを軸周りに回転させてオブジェクトを作成します
• 分割: 分割面をオブジェクトに交差させることで切断面を作成します
• 面取り: オブジェクトのエッジを面取りします
• ミラー: 指定された鏡面に対して選択されたオブジェクトの鏡像を作成します

2D図面へのエクスポート

2D図面を作成、設定、エキスポートするためのツールです。

外部レンダラーへのエクスポート

作成した3D作品を外部のレンダラーにエクスポートするためのツールです。

• POV-Rayオブジェクトの新規作成: ドキュメントに新しいPOV-Rayプロジェクトを挿入します
• ビューをPOV-Rayにエクスポート: アクティブな3Dビューのカメラ位置と内容全てをPOV-Rayファイルに書き込みます
• カメラをPOV-Rayにエクスポート: アクティブな3Dビューのカメラ位置をPOV-Rayフォーマットでファイルに書き込みます
• 部品をPOV-Rayにエクスポート: 選択された部品（オブジェクト）をPOV-Rayファイルとして書き込みます

スクリプト

最後はFreeCADの最も強力な機能の一つ、スクリプト環境です 。統合されたPythonコンソールから（あるいは他の外部のPythonスクリプトからでも）、FreeCADのほとんど全ての機能へアクセスできます。ジオメトリの作成や修正、3Dシーンでのオブジェクトの表示方法の変更、FreeCADインターフェースへのアクセスや変更が可能です。Pythonスクリプトはまたマクロとしても使用され、カスタムコマンドを簡単に作成することができます。

FreeCADでの作業

3次元空間での操作

FreeCAD のマウスモデルは3D空間を視覚的に移動し、表示されたオブジェクトを操作するために使用されるコマンドから構成されます。FreeCADには現在、3つの異なるマウス操作方法があります。デフォルトの操作スタイルは"CAD操作モード"と呼ばれています。これはとてもシンプルかつ実用的ですがFreeCADにはこの他にInventorとBlenderの操作方法にならった二つの別の操作スタイルがあります。

操作

オブジェクトの操作は全てのワークベンチで共通です。選択された各操作スタイルに従って下記のマウス操作でオブジェクトの位置と表示をコントロールすることが可能です。

操作スタイルの変更には二つのやり方があります：

• ユーザー環境設定内のDisplayセクションの3D Viewタブで変更
• 3Dビュー領域の何もない場所で右クリックし、コンテキストメニューでNavigation styleを選択

CAD操作モード（デフォルト）

デフォルトの操作スタイルでユーザーは簡単に表示をコントロールすることができます。また複数選択時以外はキーボードでのキー操作は必要ありません。

選択	平行移動	拡大縮小	回転表示
選択したいオブジェクトの上で左マウスボタンを押してください。Ctrlを押したまま操作すると複数のオブジェクトを選択できます。	マウス中央ボタンを押して動かしてオブジェクトを平行移動させます。	拡大縮小にはマウスホイールを使用してください。	まず中央マウスボタンを押し、そのまま表示されているオブジェクトの任意の点で左ボタンをクリックして好きな方向にドラッグします。こうすると中心の周りを回転する球のように回転が行われます。ドラッグを止める前にボタンを離すとオブジェクトは回転し続けます（有効になっている場合）。オブジェクト上の任意の点でマウスの中央ボタンをダブルクリックするとその点が回転、拡大縮小の原点に設定されます。

Inventor操作モード

Inventor操作モードではマウスだけでの選択ができません。オブジェクトを選択するためにはCTRLキーを押しておく必要があります。

選択	平行移動	拡大縮小	回転表示
ctrl +		or
Ctrlを押したまま選択したいオブジェクトの上で左マウスボタンをクリックしてください	左マウスボタンをクリックしてオブジェクトの周りを動かしてください	拡大縮小にはマウスホイールを使うか、中央マウスボタンを押したまま左マウスボタンをクリックしてください。	回転には左マウスボタンをクリックしてからドラッグしてください。

Blender操作モード

Blender操作モードではマウスだけでの平行移動ができません。表示を平行移動するためにはSHIFTを押しておく必要があります。

選択	平行移動	拡大縮小	回転表示
	shift+
選択したいオブジェクトの上で左マウスボタンをクリックしてください。	Shiftを押したまま中央マウスボタンをクリックしてオブジェクトの周りを動かしてください。	拡大縮小にはマウスホイールを使ってください。	中央マウスボタンをクリックしてドラッグしてください。

オブジェクトの選択

左マウスボタンで3Dビュー上のオブジェクトをクリックするか、またはツリービュー上のオブジェクトを選択することでオブジェクトを選択することができます。また選択前のマウスが上に乗った段階でオブジェクトをハイライト表示して情報を表示するプリ選択機能もあります。もしこの機能が不要だと感じたり、遅いマシン上で作業している場合はプリファレンスでプリ選択をオフにすることができます。

オブジェクトの操作

FreeCADはオブジェクトやその表示を変更するための操作を提供します。簡単な例としては平面のクリッピング が挙げられ、これはView→Clipping Planeから開始できます。平面のクリッピングを開始するとわかりやすく七つの小さな直方体でできた取手がついたオブジェクトが表示されます。三つの座標軸の端点と、平面法線軸の中央にそれぞれ一つずつあります。それほどわかりやすくありませんがさらに四つの部品があります。平面それ自体と三軸の細い部分のオブジェクトです。

拡大縮小

オブジェクトを拡大縮小するには軸の端点にある直方体の取手を左マウスボタンでクリックして前後に引っ張ります。オブジェクトに依存して取手は独立して動作したり、同調して動作したりします。

平面外への移動

オブジェクトを法線ベクトルに沿って平行移動するには軸中央の長い直方体を左マウスボタンでクリックして引っ張ります。平面のクリッピングでは法線ベクトルに沿った取手は一つだけ表示されます。

平面内の移動

クリッピング平面の中心を動かすには平面オブジェクトをクリックし、動かしたい方向に引っ張ります。

回転

軸の細い部分をクリックし、回転方向に引っ張ります。

ハードウェアのサポート

FreeCADはいくつかの3D入力デバイスをサポートしています。

FreeCADのドキュメント

FreeCADドキュメントには作成したシーンの全てのオブジェクトが保持されます。そこには全てのワークベンチで作成したグループ、オブジェクトが含まれます。従ってワークベンチを切り替えた場合でも同じドキュメントで作業を続けることができます。作業物を保存するとドキュメントはディスクに保存されます。またFreeCADでは複数のドキュメントを同時に開いたり、同じドキュメントのビューを複数開くことが可能です。

ドキュメント内ではオブジェクトをグループに移動することが可能です。またオブジェクトには固有の名前が付けられます。グループ、オブジェクト、オブジェクト名の管理は主にツリービューから管理します。もちろんFreeCADの他の全てと同様にPythonインタープリターから処理することも可能です。ツリービューではツリービューまたは各オブジェクトを右クリックすることでグループの作成、オブジェクトのグループへの移動、オブジェクト・グループの削除行うことができます。また名前をダブルクリックすることでオブジェクトの名前を変更できます。それ以外にも現在のワークベンチに応じてさまざまな操作が可能になっています。

FreeCADドキュメント内部のオブジェクトには色々なタイプがあります。各ワークベンチではそのワークベンチ固有のタイプのオブジェクトを作成できます。例えばメッシュワークベンチではメッシュオブジェクトを、パートワークベンチではパートオブジェクトを作成でき、また製図ワークベンチでもパートオブジェクトを作成できる、といった具合になっています。

もしFreeCADで一つでもドキュメントを開いている場合には常にただ一つのアクティブなドキュメントが存在することになります。3Dビューに表示され、現在作業を行なっているドキュメントがそれです。

アプリケーションとユーザーインターフェイス

FreeCADの他のほとんどのものと同様、ユーザーインターフェイス部分（GUI）は基本アプリケーション部分（APP）から独立しています。これはドキュメントについても当てはまることです。ドキュメントも二つの部分から構成されています。オブジェクトを保持すApplicationドキュメントと画面上でのオブジェクトの表示を保持するViewドキュメントです。

オブジェクトが定義されている二つの空間を想像してください。オブジェクトの構造的なパラメーター（立方体なのか？円錐なのか？そのサイズは？）はApplicationドキュメントに保持され、グラフィック表現（黒い線で描画されているのか？青い面があるのか？）はViewドキュメントに保持されます。なぜそんな風になっているのか？それはFreeCADをグラフィックインターフェイス無しでも使えるようにするためです。例えば他のプログラムの内部では画面上に何も書かないでオブジェクトを操作できなくてはなりません。

Viewドキュメント内部にはそれ以外にも3Dビューが保持されています。一つのドキュメントは複数のビューとして開くことができるので、当然、ドキュメントは同時に複数の視点から表示できなくてはならないことがわかります。あなたは作業物の上面図と正面図を同時に見たいと思ったことがあるのではないでしょうか？その場合、同じドキュメントの二つのビューが作られ、それらは両方ともViewドキュメントに保存されます。新しいビューの作成と終了はViewメニューから、またはビューのタブを右クリックすることで可能です。

スクリプト処理

Pythonインタープリターからドキュメントの作成、アクセス、変更を簡単に行うことができます。以下に例をあげます。

FreeCAD.ActiveDocument

現在の（アクティブな）ドキュメントを返します

FreeCAD.ActiveDocument.Blob

ドキュメント内部の"Blob"という名前のオブジェクトにアクセスします

FreeCADGui.ActiveDocument

現在のドキュメントに関連付けられたViewドキュメントを返します

FreeCADGui.ActiveDocument.Blob

Blobオブジェクトのグラフィック表現（ビュー）部分にアクセスします

FreeCADGui.ActiveDocument.ActiveView

現在のビューを返します

ユーザー環境設定

FreeCADのシステム設定はEditメニューのPreferencesにあります。

FreeCADの機能は異なるモジュールに分割され、各モジュールは特定のワークベンチの処理を担います。またFreeCADは遅延ロードと呼ばれるコンセプトを採用しています。つまりコンポーネントはそれが必要になった時点で読み込まれるのです。FreeCADのツールバーでワークベンチを選択するとそのワークベンチとそれに関係したコンポーネントがその瞬間に読み込まれることにあなたは気がついたのではないでしょうか。ワークベンチの環境設定もそこに含まれます。

全般的な環境設定

ワークベンチの読み込みなしでFreeCADを起動している場合、最低限の環境設定ウィンドウが表示されます。追加モジュールを読み込むと環境設定ウィンドウに新しいセクションが表示され、各ワークベンチの詳細を設定することができるようになります。

モジュールの読み込みをおこなっていない場合には二つの設定欄にアクセスできます。全般的なアプリケーション設定と表示設定です。

表示設定

FreeCADは常に進化しているので画面表示が上記のスクリーンショットと異なる可能性があります。通常、設定は見れば分かるようになっているので必要なFreeCADの設定を行うのは難しくないはずです。

インターフェイスのカスタマイズ

FreeCADのインターフェイスは現代的なQtツールキットを基盤としているため最先端の構成を備えています。ウィジット、メニュー、ツールバーやその他のツールは変更、移動、ワークベンチ間での共有が可能です。またキーボードショートカットを設定、変更したり、マクロを記録、再生したりすることもできます。カスタマイズ用ウィンドウはメニューのTools -> Customizeで開くことができます。

Commandsタブではカテゴリーごとに分類された利用可能な全てのFreeCADコマンドを見ることができます。

Keyboardでは各FreeCADコマンドに関連付けられたキーボードショートカットを確認でき、必要な場合にはそれを変更したり任意のコマンドに新しいショートカットを割り当てることができます。もしあなたが特定のワークベンチを頻繁に使い、キーボードを使ってその操作をスピードアップしたいのであればぜひこの機能を利用してください。

ToolbarsタブとToolbox barsタブでは現在のツールバーを変更したり、あなた独自のカスタマイズしたツールバーを作成することができます。

Macrosタブでは保存されたマクロを管理することができます。

オブジェクトのプロパティ

プロパティとはFreeCADドキュメントあるいはドキュメント内のオブジェクトに付けられた数字やテキスト文字列といった情報のことです。

プロパティはFreeCADで非常に重要な役割を果たしています。パラメトリックなオブジェクトを使って作業を始めた瞬間からそうなのです。パラメトリックなオブジェクトはそのプロパティのみによって定義されているのですから。

FreeCADのカスタムされたスクリプト化されたオブジェクトは以下の型のプロパティを持つことができます。

Boolean
Float
FloatList
FloatConstraint
Angle
Distance
Integer
IntegerConstraint
Percent
Enumeration
IntegerList
String
StringList
Link
LinkList
Matrix
Vector
VectorList
Placement
PlacementLink
Color
ColorList
Material
Path
File
FileIncluded
PartShape
FilletContour
Circle

ワークベンチでの作業

RevitやCatiaといった多くの現代的なデザインのためのアプリケーションと同様、FreeCADはワークベンチというコンセプトを基盤にしています。ワークベンチとは言うなれば特定の作業のために特別に編成されたツールのセットです。伝統的な家具工房では木材を扱う者のための作業台や金属部品を扱う者のための作業台があり、恐らくは全ての部品を一つに組み立てる者のための作業台もあったことでしょう。

FreeCADでは同じ考え方を採用しています。関係する作業に従ってツールはワークベンチにグループ化されているのです。

今のところ以下のワークベンチが利用可能になっています：

• パートデザインワークベンチ スケッチからの部品形状の作成用
• 製図ワークベンチ ベーシックな2D-CAD製図用
• メッシュワークベンチ 三角形メッシュでの作業用
• パートワークベンチ CAD部品での作業用
• 画像ワークベンチ ビットマップ画像での作業用
• レイトレーシングワークベンチ レイトレーシング（レンダリング）作業用
• ドローイングワークベンチ 3D作業物の2Dシート上への表示用
• ロボットワークベンチ ロボットの動作の研究用
• スケッチャーワークベンチ 幾何学的制約のあるスケッチでの作業用
• 建築ワークベンチ 建築物での作業用
• OpenSCADワークベンチ OpenSCADとの相互運用とCSGモデルヒストリーの修正用
• アセンブリワークベンチ 複数のシェイプ、ドキュメント、ファイル、関連物などでの作業用。

複数の新しいワークベンチが開発中です。お楽しみに！

ワークベンチを切り替えるとインターフェイスが変わってそのツールが利用可能になります。ツールバー、コマンドバー、さらにはインターフェイスの他の部分も新しいワークベンチに切り替わりますが、シーンの内容は変わりません。例えば製図ワークベンチで2D形状を描画し、さらにパートワークベンチを使ってそこから作業を続けるといったことが可能です。

メッシュワークベンチ

メッシュワークベンチでは三角形メッシュを取り扱えます。メッシュは3Dオブジェクトの特別なタイプの一つで、エッジと角（頂点とも呼ばれます）によってつながった三角形によって構成されます。

メッシュオブジェクトの一例

Sketchup、Blender、 Maya、3d studio maxといった多くの3Dアプリケーションでは基本となる3Dオブジェクトのタイプとしてメッシュを使用しています。これはメッシュが頂点（点）、エッジ、（三角形）面のみからなる非常にシンプルなオブジェクトで作成や変更、分割、伸縮をとても簡単に行うことができ、劣化なしで容易にアプリケーション間でのやり取りができるためです。また非常にシンプルなデータからできているので3Dアプリケーションは非常に大量のデータであっても普通は問題を起こすことなく扱うことができます。これらの理由からしばしばメッシュは映画やアニメーション、画像作成といったアプリケーションで取り扱う3Dオブジェクトの選択肢となります。

しかしエンジニアリング分野ではメッシュには大きな欠点があります。点とラインと面だけでできているせいで非常に融通がききづらいのです。メッシュは面だけで形づくられ、体積情報がないのでソリッドとして振る舞うことができません。メッシュではある点がオブジェクトの内側にあるのか外側にあるのか自動で判定する方法がありません。つまり加算や減算に代表される全てのソリッドベースの操作はメッシュに対して行うことがかなり難しく、エラーが起きやすいのです。

FreeCADはエンジニアリング用のアプリケーションですから体積、ソリッドとしての振る舞いを表す情報、さらにはカスタマイズしたパラメーターなどもっと多くの情報を持つことのできるより知的な3Dオブジェクトを使いたいと思うのは当然のことでしょう。メッシュモジュールははじめはテスト用ベッドとして使うために作成されました。しかしメッシュを読み込み、操作し、変換できるということがFreeCADにとって非常に重要な機能であることも確かです。作業の中でメッシュ形式の3Dデータを受け取るということは非常によくあることです。そういったデータを取り扱う必要がある場合、それをもっと知的なオブジェクトに変換することを妨げている形状エラーやその他の問題を解析し、最終的にもっと知的なオブジェクトに変換することでパートモジュールで取り扱うことができるようになります。

メッシュモジュールの使用方法

メッシュモジュールの現在のインターフェイスは非常にシンプルで全ての機能はMeshメニューにまとめられています。メッシュに対して行うことのできる操作の中でももっとも重要なものは以下の通りです：

• 複数のファイルフォーマットでのメッシュのインポート
• 複数のファイルフォーマットでのメッシュのエクスポート
• パートオブジェクトのメッシュへの変換
• 曲率、面の解析とメッシュを問題なくソリッドに変換できるかどうかのチェック
• メッシュ法線の反転
• メッシュに開いた穴の穴埋め
• メッシュ面の除去
• メッシュの結合、減算、交差
• 直方体、球、円錐、円筒といったメッシュプリミティブの作成
• ラインに沿ったメッシュの切断

今のところメッシュモジュールのインターフェイスにはいくつかの基本的な操作しかありません。しかし スクリプトを使用すればさらに多くの処理をFreeCADのメッシュに対して行うこともできます。

パートワークベンチ

FreeCADのCAD機能はOpenCasCadeカーネルをその基礎としています。FreeCADはパートモジュールによってOpenCasCadeオブジェクトとその機能へのアクセス・利用を行なっています。OpenCascadeはプロフェッショナル用のCADカーネルでその機能は3D形状操作、3D形状オブジェクトに特化しています。メッシュモジュール のオブジェクトと異なりパートオブジェクトはより複雑で、明確なブーリアン演算、変更履歴、パラメトリックな動作などのより高度な処理が可能です。

FreeCADでのパート形状の例

ツール

パートモジュールツールは全てパートモジュールを読み込んだ時点で表示されるPartメニューにあります。

プリミティブ

プリミティブオブジェクトを作成するためのツールです。

• ボックス: 寸法を指定してボックスを描きます
• 円錐: 寸法を指定して円錐を描きます
• 円筒: 寸法を指定して円筒を描きます
• 球: 寸法を指定して球を描きます
• トーラス: 寸法を指定してトーラス（円環）を描きます

オブジェクトの変更

既存のオブジェクトを変更するためのツールです。変更するオブジェクトを選択して使用します。

• ブーリアン: オブジェクトのブーリアン演算を行います
• 結合: 二つのオブジェクトを結合します（和集合）
• 共通部: 二つのオブジェクトの共通部分を抽出します（共通集合）
• 切り取り: オブジェクトを別のオブジェクトから切り取ります（減算）
• 押し出し: オブジェクトの平面を押し出します
• フィレット: オブジェクトのエッジをフィレット処理（丸め処理）します
• 回転体: 別のオブジェクトを軸周りに回転させてオブジェクトを作成します
• 分割: 分割面をオブジェクトに交差させることで切断面を作成します
• 面取り: オブジェクトのエッジを面取りします
• ミラー: 指定された鏡面に対して選択されたオブジェクトの鏡像を作成します

ブーリアン演算

結合（ヒューズ）、交差（共通部分）、差（カット）の一例

概念の説明

OpenCasCadeにおける用語では幾何プリミティブと（位相）シェイプは明確に区別されます。幾何プリミティブとは点、ライン、円、平面、それにB-スプライン曲線や曲面などのより複雑なタイプのものです。シェイプは頂点、エッジ、ワイヤー、面、ソリッド、それに他のシェイプの合成物です。幾何プリミティブは3Dシーン上に直接表示されることはありませんがシェイプの形状を作成するためには重要な役割を果たします。例えばエッジははラインまたは円の一部から作成されます。

つまり幾何プリミティブとは"形のない"構成単位であり、シェイプはその上に作られた実際の空間的な形状であると言えるでしょう。

その完全なリストを入手したい場合はOCCドキュメント（あるいはsourcearchive.com）を参照し、 Geom_*（幾何プリミティブの場合）とTopoDS_*（シェイプの場合）を検索してください。幾何オブジェクトとシェイプの違いについてより詳しい説明を読むことができます。残念なことに公式のOCCドキュメントはオンラインで利用することができず（アーカイブをダウンロードしなければなりません）、またそのほとんどがプログラマー向けのものでエンドユーザーに向けたものではないことに注意してください。ただしこれから始めるために必要な情報についてはここで十分確認することができるはずです。

実のところ幾何オブジェクトは大きく二つに分けることができます。カーブとサーフェスです。カーブ（ライン、円・・・）からはエッジを直接的に作成でき、サーフェス（平面、円筒・・・）からはフェイスを作成できます。例えば幾何プリミティブのラインは無限の長さを持ちます。つまり基底ベクトルと方向ベクトルによって定義されているのです。しかしそのシェイプ表現は始点と終点によって長さを制限されなければなりません。同様に直方体 -- ソリッド -- は六つの制限つき平面によって作成されます。

エッジやフェイスからはその対となる幾何プリミティブに戻ることもできます。

このようにしてシェイプから非常に複雑なパーツを作成したり、逆に複雑なシェイプからそれを構成するサブシェイプを全て抜き出したりすることが可能になっているのです。

スクリプト処理

パートモジュールで使用されている主なデータ構造はOpenCascadeのBRep（境界表現）データ型です。 現在ではパートモジュールのほとんど全ての機能とオブジェクト型がPythonスクリプトから利用可能になっています。これにはLineやCircle（あるいはArc）などの幾何プリミティブとVertexes、Edges、Wires、Faces、SolidsそしてCompoundsなどTopoShapesの全てが含まれます。これらの各オブジェクトにはいくつかの異なる作成方法があり、またオブジェクトの一部、特にTopoShapesではブーリアン演算の和集合/差集合/共通集合といったより高度な操作が可能になっています。パートモジュールの機能の詳細についてはFreeCADスクリプト処理の基礎ページを調べてください。

例

ライン要素を作成するにはPythonコンソールを開き、以下のように入力します：

import Part,PartGui 
doc=App.newDocument()  
l=Part.Line()
l.StartPoint=(0.0,0.0,0.0)
l.EndPoint=(1.0,1.0,1.0)
doc.addObject("Part::Feature","Line").Shape=l.toShape() 
doc.recompute()

上記のPythonスクリプトの例をステップごとに見ていきましょう：

import Part,PartGui
doc=App.newDocument()

パートモジュールを読み込み、新しいドキュメントを作成します。

l=Part.Line()
l.StartPoint=(0.0,0.0,0.0)
l.EndPoint=(1.0,1.0,1.0)

ラインは実際は線分なので始点と終点があります。

doc.addObject("Part::Feature","Line").Shape=l.toShape()

Partオブジェクト型をドキュメントに追加し、追加したオブジェクトの'Shape'プロパティに線分のシェイプ表現を代入します。ここで理解すべき重要な点は幾何プリミティブ（Part.Line）を使ってそこから位相シェイプを作成した（toShape()メソッド）ということです。ドキュメントに追加できるのはシェイプだけです。FreeCADでは幾何プリミティブはシェイプのための"作成用構造体"として使用されます。

doc.recompute()

ドキュメントを更新します。新しいパートオブジェクトの視覚的な表現を用意するための処理でもあります。

LineはPart.Line(point1,point2)という風にその始点と終点をコンストラクタで直接指定して作成することもできますし、ここで行ったようにデフォルトのラインを作成してあとでそのプロパティを設定することもできるということを憶えておいてください。

同じようにして円を作ることもできます：

import Part
doc = App.activeDocument()
c = Part.Circle() 
c.Radius=10.0  
f = doc.addObject("Part::Feature", "Circle")
f.Shape = c.toShape()
doc.recompute()

先ほどと同様、円（幾何プリミティブ）を使ってそのシェイプを作成しました。もちろんこの後、下記のような方法で作成した形状にアクセスすることができます：

s = f.Shape
e = s.Edges[0]
c = e.Curve

ここではオブジェクトfのシェイプを取得した後、そのエッジのリストを取得しています。今回の場合、エッジは一つしかありません。円一つからシェイプ全体を作成しているためです。従ってEdgesリストの最初のアイテムだけ取得し、その後でそのCurve（曲線）を取得しています。Edgeは全てCurveを持ちます。これはエッジの元になっている幾何プリミティブです。

さらに詳しく知りたい場合は位相データのスクリプト処理ページを見て下さい。

ドローイングワークベンチ

ドローイングモジュールを使うと3D作業物を紙の上に移すことができます。つまりモデルのビューを2Dウィンドウに表示し、図面にそのウィンドウを挿入するということです。例えば枠線、タイトル、ロゴマークが入ったシートに挿入し、最終的にそのシートを印刷することができます。ドローイングモジュールは現在も製作中で多かれ少なかれ技術面でのテスト段階にあります！

GUIツール

2D図面を作成、設定、エキスポートするためのツールです。

この画像を見るとドローイングモジュールの主要なコンセプトが見て取れます。ドキュメントには図面に引用したい形状オブジェクト（Schenkel）が入っています。さらに"Page"が作成されています。ページはテンプレートに基づいてインスタンス化されます。今回のケースでは"A3_Landscape"テンプレートです。テンプレートにはSVGドキュメントであなたが普段使っているページ枠、ロゴ、標準のプレゼンテーション資料規格を使うことができます。

このページには複数のビューを挿入することができます。各ビューはページ上での位置（X、Yプロパティ）、拡大率（スケールプロパティ）などをはじめとした属性情報を持っています。ページ、ビュー、参照しているオブジェクトが変化するとそのたびにページが再生成され、ページの表示が更新されます。

スクリプト処理

今のところエンドユーザー用の（GUI）ワークフローは非常に限定されたものしか用意されていません。APIはもっと充実しています。以下ではドローイングモジュールのスクリプト処理用APIをどう使うかの例を挙げていきます。

簡単な例

まずはパートモジュールとドローイングモジュールが必要です。

import FreeCAD, Part, Drawing

小さなサンプルパーツを作成します。

Part.show(Part.makeBox(100,100,100).cut(Part.makeCylinder(80,100)).cut(Part.makeBox(90,40,100)).cut(Part.makeBox(20,85,100)))

投影させます。G0はシャープな輪郭線、G1は連続線を意味します。

Shape = App.ActiveDocument.Shape.Shape
[visibleG0,visibleG1,hiddenG0,hiddenG1] = Drawing.project(Shape)
print "visible edges:", len(visibleG0.Edges)
print "hidden edges:", len(hiddenG0.Edges)

全てZ平面に投影されます。

print "Bnd Box shape: X=",Shape.BoundBox.XLength," Y=",Shape.BoundBox.YLength," Z=",Shape.BoundBox.ZLength
print "Bnd Box project: X=",visibleG0.BoundBox.XLength," Y=",visibleG0.BoundBox.YLength," Z=",visibleG0.BoundBox.ZLength

異なる投影ベクトル。

[visibleG0,visibleG1,hiddenG0,hiddenG1] = Drawing.project(Shape,App.Vector(1,1,1))

SVGに投影。

resultSVG = Drawing.projectToSVG(Shape,App.Vector(1,1,1))
print resultSVG

パラメトリックな方法

物体を作成します。

# 直方体を三つ、円筒を一つ作成
App.ActiveDocument.addObject("Part::Box","Box")
App.ActiveDocument.Box.Length=100.00
App.ActiveDocument.Box.Width=100.00
App.ActiveDocument.Box.Height=100.00

App.ActiveDocument.addObject("Part::Box","Box1")
App.ActiveDocument.Box1.Length=90.00
App.ActiveDocument.Box1.Width=40.00
App.ActiveDocument.Box1.Height=100.00

App.ActiveDocument.addObject("Part::Box","Box2")
App.ActiveDocument.Box2.Length=20.00
App.ActiveDocument.Box2.Width=85.00
App.ActiveDocument.Box2.Height=100.00

App.ActiveDocument.addObject("Part::Cylinder","Cylinder")
App.ActiveDocument.Cylinder.Radius=80.00
App.ActiveDocument.Cylinder.Height=100.00
App.ActiveDocument.Cylinder.Angle=360.00
# 二つの直方体と円筒を結合
App.activeDocument().addObject("Part::Fuse","Fusion")
App.activeDocument().Fusion.Base = App.activeDocument().Cylinder
App.activeDocument().Fusion.Tool = App.activeDocument().Box1

App.activeDocument().addObject("Part::Fuse","Fusion1")
App.activeDocument().Fusion1.Base = App.activeDocument().Box2
App.activeDocument().Fusion1.Tool = App.activeDocument().Fusion
# 一つ目の直方体で結合した形状を切断
App.activeDocument().addObject("Part::Cut","Shape")
App.activeDocument().Shape.Base = App.activeDocument().Box
App.activeDocument().Shape.Tool = App.activeDocument().Fusion1
# 作業した形状を全て非表示にする
Gui.activeDocument().Box.Visibility=False
Gui.activeDocument().Box1.Visibility=False
Gui.activeDocument().Box2.Visibility=False
Gui.activeDocument().Cylinder.Visibility=False
Gui.activeDocument().Fusion.Visibility=False
Gui.activeDocument().Fusion1.Visibility=False

Pageオブジェクトを挿入し、テンプレートを代入

App.activeDocument().addObject('Drawing::FeaturePage','Page')
App.activeDocument().Page.Template = App.getResourceDir()+'Mod/Drawing/Templates/A3_Landscape.svg'

"Shape"オブジェクトのビューを作成。位置とサイズを定義してPageに代入

App.activeDocument().addObject('Drawing::FeatureViewPart','View')
App.activeDocument().View.Source = App.activeDocument().Shape
App.activeDocument().View.Direction = (0.0,0.0,1.0)
App.activeDocument().View.X = 10.0
App.activeDocument().View.Y = 10.0
App.activeDocument().Page.addObject(App.activeDocument().View)

同じオブジェクトに対して二つ目のビューを作成。ただし今回のビューは90度回転させます。

App.activeDocument().addObject('Drawing::FeatureViewPart','ViewRot')
App.activeDocument().ViewRot.Source = App.activeDocument().Shape
App.activeDocument().ViewRot.Direction = (0.0,0.0,1.0)
App.activeDocument().ViewRot.X = 290.0
App.activeDocument().ViewRot.Y = 30.0
App.activeDocument().ViewRot.Scale = 1.0
App.activeDocument().ViewRot.Rotation = 90.0
App.activeDocument().Page.addObject(App.activeDocument().ViewRot) 

同じオブジェクトに対して三つ目のビューを作成。ただし等角図の方向を使用します。また隠れている線も表示させます。

App.activeDocument().addObject('Drawing::FeatureViewPart','ViewIso')
App.activeDocument().ViewIso.Source = App.activeDocument().Shape
App.activeDocument().ViewIso.Direction = (1.0,1.0,1.0)
App.activeDocument().ViewIso.X = 335.0
App.activeDocument().ViewIso.Y = 140.0
App.activeDocument().ViewIso.ShowHiddenLines = True
App.activeDocument().Page.addObject(App.activeDocument().ViewIso) 

適当に何か変更して更新。更新処理によってビューとページが変化します。

App.activeDocument().View.X = 30.0
App.activeDocument().View.Y = 30.0
App.activeDocument().View.Scale = 1.5
App.activeDocument().recompute()

こまごまとした物へのアクセス

一つのビューからSVGの図を取得。

ViewSVG = App.activeDocument().View.ViewResult
print ViewSVG

結果ページ全体を取得（ドキュメントのテンポラリフォルダ内の読み取り専用ファイル）。

print "Resulting SVG document: ",App.activeDocument().Page.PageResult
file = open(App.activeDocument().Page.PageResult,"r")
print "Result page is ",len(file.readlines())," lines long"

重要：ファイルを解放！

del file

独自のコンテンツを使用してビューを挿入。

App.activeDocument().addObject('Drawing::FeatureView','ViewSelf')
App.activeDocument().ViewSelf.ViewResult = """<g id="ViewSelf"
  stroke="rgb(0, 0, 0)"
  stroke-width="0.35"
  stroke-linecap="butt"
  stroke-linejoin="miter"
  transform="translate(30,30)"
  fill="#00cc00"
  >

  <ellipse cx="40" cy="40" rx="30" ry="15"/>
  </g>
"""
App.activeDocument().Page.addObject(App.activeDocument().ViewSelf)
App.activeDocument().recompute()

del Shape,ViewSVG, resultSVG

以下のような結果になります：

テンプレート

FreeCADには一通りのデフォルトテンプレートが付属していますがドローイングテンプレートにはもっと多くのテンプレートがあります。

レイトレーシングワークベンチ

このモジュールはシーンの内容を外部のレンダラーに送り出し、作業物のフォトリアリスティックな画像を生成することを目標にしています。レイトレーシングモジュールはまだまだ未完成な初期段階にあり、今のところはそう多くの機能はありません。現在はパートオブジェクトをPOV-rayファイルとしてエクスポートするための基本的なツールのみ実装されています。エクスポートしたファイルはPOV-rayで読み込んでレンダリングすることができます。

GUIツール

作成した3D作品を外部のレンダラーにエクスポートするためのツールです。

• POV-Rayオブジェクトの新規作成: ドキュメントに新しいPOV-Rayプロジェクトを挿入します
• ビューをPOV-Rayにエクスポート: アクティブな3Dビューのカメラ位置と内容全てをPOV-Rayファイルに書き込みます
• カメラをPOV-Rayにエクスポート: アクティブな3Dビューのカメラ位置をPOV-Rayフォーマットでファイルに書き込みます
• 部品をPOV-Rayにエクスポート: 選択された部品（オブジェクト）をPOV-Rayファイルとして書き込みます

ビューのエクスポート

もっとも簡単な方法は現在の3Dビューとその内容全てをPOV-rayファイルにエクスポートするというものです。まずCADデータを読み込むか作成するかし、適当な3D表示の位置に設定する必要があります。その後、Raytracingメニューから"Export View..."を選択します。

結果*.povファイルの保存位置を尋ねられます。保存が終わるとPOV-rayでそれを開き、レンダリングすることができます。

普段、レンダラーで行うのと同じように大きくてきれいな画像を作成できます：

スクリプト処理

モジュールの機能をPythonから使用する方法です：

import Raytracing,RaytracingGui
OutFile = open('C:/Documents and Settings/jriegel/Desktop/test.pov','w')
OutFile.write(open(App.getResourceDir()+'Mod/Raytracing/Templates/ProjectStd.pov').read())
OutFile.write(RaytracingGui.povViewCamera())
OutFile.write(Raytracing.getPartAsPovray('Box',App.activeDocument().Box.Shape,0.800000,0.800000,0.800000))
OutFile.close()
del OutFile

リンク

POV-Rayについて：

• http://www.spiritone.com/~english/cyclopedia/
• http://www.povray.org/
• http://en.wikipedia.org/wiki/POV-Ray

現在、LuxRendererやYafarayといった複数のバックエンドをサポートするために新しくレンダラーワークベンチが開発中です。開発版を使用するための情報はレンダラープロジェクトで見ることができます。

レンダラーモジュールの開発ステータスについてはレイトレーシングプロジェクト を見てください。

オープンソースのレンダラー（将来的に実装予定）

• http://www.yafaray.org/
• http://www.luxrender.net/

画像ワークベンチ

画像モジュールは様々なタイプのビットマップ画像を扱うためのもので、FreeCADでそれらの画像を開くことを可能にします。現在のところ、このモジュールでは.bmp、.jpg、.pngそして.xpmの形式のファイルを分離表示されるビューワーウィンドウで開くことができます。またWebカメラからの画像をキャプチャーすることが可能なツールもあります。

製図ワークベンチ

製図ワークベンチを使うと現在のドキュメントにシンプルな2Dオブジェクトを手軽に描くことができます。また描いた後でそれらを変更するためのツールもいくつか用意されています。ツールの一部は製図ワークベンチで作成したものだけでなく他のFreeCADオブジェクト全てに対して使用することができます。また完璧に動作するスナップシステムやオブジェクトと設定を管理するためのいくつかのユーティリティも提供されています。

===作図オブジェクト===

オブジェクトを作成するためのツールです。

ファイル形式

製図モジュールによってFreeCADは以下のファイル形式をインポート、エクスポートできるようになっています。

• Autodesk .DXF: 2D-CADアプリケーションを使って作成されたDrawing Exchange Formatファイルのインポートとエクスポート
• SVG（形状）: ベクター描画アプリケーションを使って作成されたScalable Vector Graphicsファイルのインポートとエクスポート
• Open Cad format .OCA: OCA/GCADファイルのインポートとエクスポート。将来的な可能性を秘めた新しい オープンなCADファイル形式です
• Airfoil Data Format .DAT: 翼型断面の記述に使用されるDATファイルのインポート

追加機能

• スナッピング: 既存オブジェクトの特定位置に新しい点を配置できます
• 拘束: 既存の点に対して相対的な水平位置、垂直位置を指定して新しい点を配置できます
• 座標入力での作業: 画面クリックの代わりに手動で座標を入力できます

環境設定

• 製図モジュールには専用の環境設定画面があります

スクリプト処理

製図モジュール機能には完全な製図用APIがあり、スクリプトやマクロからその機能を使用することができます

Tutorials

Draft tutorial

スクリプトとマクロ

マクロでの作業

マクロはFreeCADに複雑なアクションを作成するための便利な方法です。簡単にあなたが行う操作を記録したものを名前をつけて保存し、いつでも好きなときに再生することができます。マクロはpythonコマンドで記述されているので、それらを編集して非常に複雑なスクリプトを作成することができます。

操作方法

コンソール出力（メニュー Edit -> Preferences -> General -> Macros -> Show scripts commands in python console）を有効にした場合は、FreeCADでは、ボタンを押すのなどのあなたが行うすべてのアクションがpythonコマンドを出力していることがわかります。 このコマンドはマクロに記録することができるものです。マクロを作成するための主なツールはマクロのツールバーです。それには、4つのボタンがあります：「記録」、「記録終了」、「編集」、「マクロの実行」です。

それを使用することは非常に簡単です：「記録」ボタンを押すと、マクロに名前を付けるように求められます。その後、いくつかのアクションを実行します。作業が完了したら、「記録終了」ボタンをクリックして、あなたの行ったアクションが保存されます。ここで「編集」ボタンを押すとマクロダイアログを開くことができます。

マクロダイアログには、あなたのマクロを管理、編集、削除、新規作成ができます。マクロを編集する場合、コードに変更を加えることができるエディタウィンドウが開きます。

例

「記録」ボタンを押して名前をつけてみましょう。"cylinder 10×10"にします。その後、パートワークベンチで、半径= 10、高さ= 10でシリンダを作成します。そして、「記録停止」ボタンを押してください。マクロ編集のダイアログでは、記録されているPythonのコードを見ることができ、必要に応じて変更を加えることができます。マクロを実行する簡単な方法は、マクロをエディタで開きツールバー上の「実行」ボタンを押します。 マクロは常にディスクに保存され、あなたが行ったすべての変更、または新しく作成したマクロはFreeCADを次回起動時も利用できるようになっています。

カスタマイズ

もちろん、マクロを使用するたびに、エディタでマクロを開くのは実用的ではありません。 FreeCADは、マクロにキーボードショートカットを割り当てる、メニューのエントリに追加するなど、マクロを使用するためのはるかに優れた方法を提供します。マクロが作成されると、Tools -> Customize メニューから設定を行うことができます

この方法であなたのマクロをFreeCADの標準ツールのように使うことができます。これは、FreeCADのpythonスクリプトの力のおかげで、インターフェイスに独自のツールを簡単に追加することができます。Pythonスクリプティングについて詳細をお知りになりたい場合はScriptingページを参照してください。

記録せずにマクロを作成する

また、直接GUI操作を記録せずに、マクロにpythonコードをコピー/ペーストすることができます。新しいマクロを作成・編集して、コードを貼り付けます。あなたのマクロはFreeCADの文書を保存するのと同じ方法で保存することができます。FreeCADを次回起動する時には、マクロは「Macro」メニューの"Installed Macros"項目の下に表示されます。

マクロリポジトリ

Macros recipesページには、あなたのFreeCADに追加できるいくつかの便利なマクロが紹介されています。

pythonの紹介

これは、Pythonをはじめる人のために作られた短いチュートリアルです。 Pythonはオープンソース、マルチプラットフォームのプログラミング言語です。 Pythonは他の一般的なプログラミング言語と違い、あなたのようなはじめてのユーザーにとって非常に使いやすくするいくつかの機能を持っています。

• 人間が読みやすいように特別に設計されたので、それを学習し理解することは非常に容易であるされています。
• C言語のようなコンパイル言語とは異なり、実行する前にコンパイルを必要とせずにコードを解釈します。あなたがそうしたい場合は、記述したコードはすぐに1行ずつ実行することができます。これは、ステップごとに実行されるので、簡単に学習でき、あなたのコード内のエラーを検出することが極めて容易になります。
• スクリプト言語として他のプログラムに埋め込むことができます。 FreeCADは、埋め込まれたPythonインタプリタを持っているので、FreeCADの部品を操作する例えばジオメトリを作成することをFreeCADのPythonコードで書くことができます。これは非常に強力でプログラマが用意した"球体作成"のボタンをクリックするかわりに自由にかつ簡単に作成した独自のツールであなたが望む正確なジオメトリを作成することができます。
• それは拡張可能であり、新しいPythonのモジュールをプラグインとして簡単にインストールし機能を拡張することができます。例えば、jpg画像の読み書き、Twitterとの通信、使用しているオペレーティングシステムによって実行されるタスクのスケジュール等のモジュールがあります。

まずは、実際に使ってみましょう！次は非常に簡単な紹介であることに注意してください。これは完全はチュートリアルではありません。しかし、私の希望は、後にFreeCADのメカニズムをより深く探求するための十分な基礎を得ることです。

インタプリタ

通常、コンピュータプログラムを書くとき、単にテキストエディタを使用するかほとんど場合は、特別なプログラミング環境のテキストエディタと周辺のツールを利用して プログラムを書き、それをコンパイルして実行します。ほとんどの場合、記述中に誤りがあるとあなたのプログラムは動作しません。そして、何が悪かったのかを伝えるエラーメッセージが表示されます。あなたはテキストエディタに戻って、間違いを修正し、再度実行するということをプログラムが正常に動作するまで繰り返します。

Pythonにおけるプロセスは、Pythonインタプリタの内部で透過的に実行できます。Pythonインタプリタは、Pythonウィンドウのコマンドプロンプトを使って簡単にPythonコードを入力することができます。お使いのコンピュータにPythonをインストールする場合は、（WindowsもしくはMacの場合はPythonのWebサイトからダウンロードしてください。GNU/Linuxの場合はパッケージリポジトリからインストールしてください）スタートメニューにPythonインタプリタが入ります。しかし、FreeCADは、ウィンドウ下部にPythonインタプリタが入っています。

（表示されない場合は、View → Views → Python consoleをクリックしてください。）

インタプリタは、Pythonのバージョンを表示し、そしてコマンドプロンプトとなる>>>のシンボルを表示します。ここへPythonコードを入力します。インタプリタでコードを書くことは簡単です：1行は1命令です。あなたがEnterを押すと、入力したコードが実行されます。（瞬時にコンパイルされます）例えば、これを書いてください。

print "hello"

print は言うまでもなく画面に何かを表示することを意味する特別なPythonのキーワードです。Enterキーを押すと、操作が実行され、"hello"というメッセージが表示されます。エラーにしたい場合は、次の例を書いてください：

print hello

Pythonは"hello"が何かを知らないということを教えてくれる。 「"」はその中身が文字列であることを指します。それはプログラミング用語において、ひとつのテキスト文字列ｆであることを示します。「"」がない場合、printコマンドは、helloがテキストの一部ではなく特別なPythonのキーワードだと思います。重要なことは、あなたがすぐにエラーになった通知を受けとれることです。上矢印を押して、（FreeCADのインタプリタの場合はCtrl + 上矢印）、あなたが書いた最後のコマンドに戻って、それを修正することができます。

Pythonインタプリタにもヘルプ機能があります。次の命令を試してください：

help

または、例として、先ほどの「print hello」コマンドを使用して何が悪かったのかわからず"print"コマンドに関する具体的な情報が欲しい時は：

help("print")

あなたは、printコマンドが実行できるすべての完全な説明を得ることができます。

今、私たちはインタプリタを使いこなせます。本気になって使いはじめましょう。

変数

もちろん、"hello"を表示することが注目すべき点ではありません。より注目すべき点は、あなたが気づかなかったことをPythonが解釈して表示していることです。 これが変数の概念です。変数は単に名前をつけて値を格納しているのです。例えば次のように入力します。

a = "hello"
print a

何がおこったのか解説すると、"hello"という文字列をaという名前をつけて格納しました。この時点でaは未知の名前ではありません！printコマンドなどで、どこでも使用することができます。スペースや句切り点を使用しないというような簡単なルールに守っていれば任意の名前を使用できます。この例は、非常によく使います。

hello = "my own version of hello"
print hello

見ましたか？helloはもう未定義の言葉ではありません。不運にもPythonで予約されているキーワードを選んだ場合はどうなりますか？"print"という名前で文字列を格納したいとしましょう：

print = "hello"

Pythonは非常に知的であり、これが不可能であることを私たちに教えてくれます。いくつかの予約されたキーワードを持っており、変更することはできません。しかし、我々の独自の変数は、正確には変数と呼ばれており、いつでも変更することができます。たとえば、次のように：

myVariable = "hello"
print myVariable
myVariable = "good bye"
print myVariable

myVariableの値を変更しました。また、変数をコピーすることができます：

var1 = "hello"
var2 = var1
print var2

あなたの使う変数に適切な名前を付けることが重要であることに注意してください。なぜなら、長いプログラムを書こうとしたときに"a"という名前の変数が何のためにあるのか覚えられないと思います。しかし、あなたが例のようにmyWelcomeMessageという変数の名前を使用した場合、あなたはその変数を見たり使ったりするときに簡単に思い出すことができます。

数値

もちろん、あなたがプログラムを作る上で文字列だけでなくすべての種類のデータ、特に数値を使うことを知っている必要があります。重要なことの一つにPythonでどのような種類のデータを使うことができるか知っておく必要があります。print helloの例題から　printコマンドで"hello"という文字列を表示できることがわかりました。それは"を使用すると、printコマンドにおいてその後に続くのが文字列であることがわかりました。

特別なPythonのキーワードを入力することにより、いつでも変数のデータ型が何なのか確認することができます:

myVar = "hello"
type(myVar)

これはmyVarの中身が'str'、つまりPython用語における文字列であることがわかります。また、他の基本的なデータ型には、整数型や浮動小数点数型などがあります:

firstNumber = 10
secondNumber = 20
print firstNumber + secondNumber
type(firstNumber)

これは、今までよりはるかに興味深いですが、それはないですか？今、私たちは、すでに強力な電卓を持っています！それが機能していることをよく見てください。Pythonは10と20が整数であることを認識しています。だからそれらは "int"型として格納されており、Pythonは整数として扱うことができます。この結果を見てください:

firstNumber = "10"
secondNumber = "20"
print firstNumber + secondNumber

見ましたか？これはPythonは2つの変数が数字ではなく単なる文字列として認識していることを意味しています。Pythonは、2つの文字列を合わせて一つにすることができますが、2つの合計を求めようとはしません。しかし、我々は、整数型のことも話題にしていました。浮動小数点型もあります。これらの違いは浮動小数点の数値は小数部を有することができ、整数の数値は、小数部を持っていないということです:

var1 = 13
var2 = 15.65
print "var1 is of type ", type(var1)
print "var2 is of type ", type(var2)

int型と浮動小数点型は問題なく一緒に混合することができます:

total = var1 + var2
print total
print type(total)

いいですか？もちろん合計は小数になります。 Pythonは自動的に結果が浮動小数点型であると判断しました。この例のように、いくつかのケースではPythonは自動的に何型かをを判断します。他のケースではそれはしていません。たとえば、次のように:

varA = "hello 123"
varB = 456
print varA + varB

これは、エラーになります。varAは文字列であり、varBのデータ型は整数型で、Pythonは何をすればいいのかわかりません。しかし、型の変換をPythonに強制することもできます:

varA = "hello"
varB = 123
print varA + str(varB)

これで、両方が文字列となり実行できます！表示する時にvarBが"文字列"となっていますが、私たちはvarB自体を変更していないことに注意してください。varBを常に文字列にしたい場合は、次のようにします:

varB = str(varB)

また、場合によって整数型や浮動小数点型に変換するためにint()やfloat()を使用することができます:

varA = "123"
print int(varA)
print float(varA)

Pythonコマンドに関する注意

このセクションでprintコマンドをいくつかの方法で使用したことに気づいている必要があります。変数の値、合計、コンマで区切られたいくつかの事項、そしてtype()のようなPythonコマンドの結果を出力しています。これらの2つのコマンドを実行してみてはどうでしょうか:

type(varA)
print type(varA)

まったく同じ結果になります。それはインタプリタであり、すべてのものが画面上に自動的に表示されているからです。インタプリタの外で複雑なプログラムを書いて実行させようと思うと、自動的にすべてが画面上に表示されないので、printコマンドを使用する必要があります。しかし、今からここではそれは使わないでおきましょう。それよりはやいからです。だから簡単に書くことができます:

myVar = "hello friends"
myVar

そのPythonコマンド（またはキーワード）のほとんどはtype()、int()、str()などのように括弧はコマンドとして動作することを伝えるために使用するとわかりました。唯一の例外は、実際は例外ではありませんがprintコマンドです。これは通常print("hello")のように動作します。しかし頻繁に使用されるのでPythonのプログラマは簡易版を作りました。

リスト

もう一つの興味深いデータ型がリストである。リストは、単にデータの配列です。""を使用して、テキスト文字列を定義するのと同じ方法で、[]を使用してリストを定義します。

myList = [1,2,3]
type(myList)
myOtherList = ["Bart", "Frank", "Bob"]
myMixedList = ["hello", 345, 34.567]

それが任意の型のデータで作成できることがわかります。変数も一緒にグループ化することができますので、リストは非常に便利です。その後、グループに対して様々な処理を行うことができます　次の例はグループ内のデータの数をカウントします：

len(myOtherList)

またはリストの中から1つのアイテムを取得します：

myName = myOtherList[0]
myFriendsName = myOtherList[1]

あなたはlen()コマンドの結果からアイテムの合計数がわかり、0から始まるリストの"位置"がわかります。リスト内の最初のアイテムが常に0の位置にあるので、myOtherListで、"Bob"は2番目の位置になります。ここを読むことによってアイテムの並び替えや削除、追加など様々な操作をおこなうことができます。

とても面白くて興味深い事:テキストの文字列は文字のリストに非常に似ています！これをやってみてください：

myvar = "hello"
len(myvar)
myvar[2]

通常、あなたがリストに対して実行できるすべての操作を文字列に対して行うことができます。実際にはリストも文字列も配列です。

文字列、整数、浮動小数点数とリストの他には、辞書にのっているような組み込みのデータ型だけではなく、クラスを使用して独自のデータ型を作成することもできます。

インデント

リストの一つのとても洗練された使用方法は、アイテムを参照して各要素で何らかの処理をすることです。例えばこれを見てください：

alldaltons = ["Joe", "William", "Jack", "Averell"]
for dalton in alldaltons:
   print dalton + " Dalton"

リストを使って（再びプログラミング専門用語！）"for ... in ..."コマンドと各要素で何らかの処理を行いました。特殊な構文に注意してください。forコマンドは、:で完了するとこその次のコマンドを1ブロックのコマンドとします。コマンドラインに:を入力すると...コマンドプロンプトに変わります。これは:が行の終わりであることを示し次に入力される行が1ブロックであるとPythonは解釈します。

Pythonはどのようにしてfor...in構文の中で実行する命令文がどれぐらいあるのかを判断するのでしょうか？そのために、Pythonはインデントを使用しています。つまり、あなたの次の命令がすぐに実行されません。あなたは空白、連続した空白、またはタブ、連続したタブを使って記述します。他のプログラミング言語では、括弧で括るなどPythonとは違う方法を使っています。 あなたは同じインデントを使用して次の命令を記述している限り、それらはfor-inのブロックの一部とみなされます。あなたは2つのスペースを使用して記述した後、次の行を4つにするとエラーが発生します。 作業が終わったら、インデントせずに別の行を書き込むか、または単にEnterを押せばfor-inのブロックから戻ってくることができます。

インデントは幅の大きなインデントを（例えば幅が大きいのでスペースの代わりにタブを使用する）使う場合、大きなプログラムを書くときにどのような処理を実行しているかを明確にすることができるのでとてもクールです。for-in以外にもコードをインデントでブロックにする多くのコマンドがあります。 for-inコマンドは命令を繰り返し実行するようなものにも使用することができます。例えばrange()コマンドと組み合わせることができます。

serie = range(1,11)
total = 0
print "sum"
for number in serie:
   print number
   total = total + number
print "----"
print total

より複雑なもの：

alldaltons = ["Joe", "William", "Jack", "Averell"]
for n in range(4):
   print alldaltons[n], " is Dalton number ", n

range()コマンドは、（あなたが開始番号を指定しない場合）0から始まる特性を持っており、最後の数は、指定した終了番号より1つ少なくなることに注意してください。それはもちろん、他のPythonコマンドでも同じです。例えば、次のように:

alldaltons = ["Joe", "William", "Jack", "Averell"]
total = len(alldaltons)
for n in range(total):
   print alldaltons[n]

インデントされたブロックのもう一つの興味深い使用方法はifコマンドを使用することです。特定の条件が満たされる場合に限り、ブロックのコードを実行します。例えば:

alldaltons = ["Joe", "William", "Jack", "Averell"]
if "Joe" in alldaltons:
   print "We found that Dalton!!!"

もちろん、これは常に最初のセンテンスを表示します。しかし、2行目を次のように書き換えると:

if "Lucky" in alldaltons:

何も表示されません。else:ステートメントを指定することができます。

alldaltons = ["Joe", "William", "Jack", "Averell"]
if "Lucky" in alldaltons:
   print "We found that Dalton!!!"
else:
   print "Such Dalton doesn't exist!"

関数

標準のPythonコマンドは、多くはありません。現在のバージョンのPythonには約30の標準コマンドがあり、すでにそれらのいくつかを知っています。しかし、独自のコマンドを考案できることを想像してみてください。さて、私たちは独自のコマンドを作ることができ、それは非常に簡単です。実際、多くの追加モジュールはあなたがコマンドを追加するだけでPythonに追加インストールされます。 Pythonでカスタムコマンドは関数と呼ばれ、このように構成されています。

def printsqm(myValue):
   print str(myValue)+" square meters"

printsqm(45)

極めてシンプルです。def()コマンドは、新しい関数を定義しています。あなたはそれに名前を付け、括弧内には、我々は関数の中で使おうとしている引数を定義します。引数は、関数に渡されるデータです。例えば、len()コマンドを見てみましょう。len()を単独で記述する場合、Pythonは引数を必要と教えてくれます。つまり、あなたは、len()を使って何かをしたいですよね？そして、例えば、あなたはlen(myList)と記述して、myListの長さを取得するとします。そしてmyListは、len()関数に渡す引数です。 len()関数は、渡された引数を使ってどのような処理を実行するのか定義されています。ここで行ったのと同じ処理です。

"myValue"の名前は何でもかまいません、それは関数の内部でのみ使用されます。 あなたが変更できるのは名前だけですが、関数が要求するする引数の数にあわせて指定します。例えば、次の場合:

printsqm(45,34)

エラーが発生します。この関数はただ1つの引数を受け取るようにプログラムされていますが、2つの引数、45および34を受け渡しました。その代わりにこのようなことができます:

def sum(val1,val2):
   total = val1 + val2
   return total

sum(45,34)
myTotal = sum(45,34)

2つの引数を受け取り合計して、その値を返す関数を作りました。値を返すことは非常に便利です。なぜならmyTotal変数に格納するなど、関数の実行結果を使って何かを行うことができます。もちろん、インタプリタであり、すべてのものを表示されるので、次を実行してください:

sum(45,34)

画面に結果を表示したいと思っていても、関数の内部にまったく表示コマンドを組み込んでいないため、画面に何も表示されないでしょう。この部分についてはあなたが行う必要があるでしょう:

print sum(45,34)

何かが表示されています。機能の詳細をお読みください。ここ

モジュール

今、Python使いこなすためには、最後に1つ必要なことがあります。それはどのようにファイルやモジュールを操作するかです。

これまで、インタプリタで1行ずつPythonの命令を書いてきましたね？もしいくつかの行をまとめて書くことができ、それらを一度にすべて実行できたらどうですか？それはもっと複雑なことをするためには手軽な手段です。さらに私たちの作ったものを保存することができます。まあ、それも非常に簡単です。単にテキストエディタ（Windowsのメモ帳など）を開き、インタプリタでプログラムを記述するのと同様にPythonのプログラムをすべて書き、その後、.pyの拡張子でこのファイルをどこかに保存します。それだけです、あなたは完全なPythonプログラムを作ることができました。もちろん、メモ帳よりも便利なエディタがありますが、それはPythonプログラムは、テキストファイル以外の何者でもないことを示しているだけです。

Pythonでプログラムを実行する方法は何百もあります。Windowsでは、単にファイルを右クリックしPythonでそれを開いて実行します。しかし、Pythonインタプリタから直接プログラムを実行することもできます。直接実行するには、Pythonインタプリタが実行しようとする.pyプログラムの保存場所を知っている必要があります。

FreeCADでの最も簡単な方法は、FreeCADのbinフォルダまたはModフォルダのようにFreeCADのPythonインタプリタにデフォルトで設定されている場所にプログラムを配置することです。次のようなファイルを作成します:

def sum(a,b):
    return a + b

print "test.py succesfully loaded"

そして作成したファイルをFreeCADの/binディレクトリにtest.pyとして保存します。さて、FreeCADを起動しましょう、そしてインタプリタウィンドウへ次のように入力します。

import test

.pyの拡張子を除いたものです。これは単にインタプリタで1行ずつ書いて実行したかのように、ファイルの内容を実行します。sum関数が作成され、メッセージが出力されます。1つの大きな違いがあります：importコマンドは、ファイルに書かれたプログラムを実行するだけでなく今までのプログラム同様内部の関数を読み込むのでインタプリタで利用できるようになります。関数を含むファイルは、モジュールと呼ばれます。

通常、インタプリタでsum()関数を記述し、実行するとき単に次のように入力します:

sum(14,45)

これは以前行ったとおりです。我々はsum()関数を含むモジュールをインポートすると、構文が少し異なっています。次のように入力します:

test.sum(14,45)

つまり、モジュールは"container"として読み込まれ、そのすべての関数は内部にあります。多くのモジュールをインポートし、すべての関数をうまく整理しておくことができるので、これは非常に有用です。したがって、基本的に、something.somethingElseのようにドットで区切ることによって、somethingElse関数がsomethingモジュールの内部にあることを意味しています。

また、testの部分を記述せずにsum()関数のように、メインのインタプリタ空間に直接関数を読み込むことができます:

from test import *
sum(12,54)

基本的に、すべてのモジュールはそのように動作します。モジュールをインポートしてから、module.function(引数)のようにその関数を使用することができます。ほとんどすべてのモジュールが関数を定義し、新しいデータ型とクラスをインタプリタ、モジュール内でモジュールをインポートすることもできるのでPythonモジュールで使えるようになります。

最後にもう一つ、非常に有用なものがあります。どのようなモジュールがありその内部にはどのような関数があってどのように使う（つまり必要とする引数の種類）かわかりますか？ Pythonがhelp()関数を持っていることをすでに知っています。次の操作をしてみましょう:

help()
modules

すべての利用可能なモジュールのリストが表示されます。対話式ヘルプから抜け出すには、qを入力し、それらのいずれかをインポートすることができます。dir()コマンドを使用してそのコンテンツを見ることができます。

import math
dir(math)

mathモジュールに含まれるすべての関数と同様、__doc__, __file__, __name__といった奇妙な名前が表示されます。__doc__ はドキュメントの文字列を表し、非常に便利です。（既存の）モジュールに含まれるすべての関数は使用方法に関する説明を__doc__に持っています。例えばmathモジュールにはsin関数含まれていることがわかります。それの使用方法が知りたいですか？

print math.sin.__doc__

最後に少し使いやすい方法は:新しいモジュールをプログラミングするとき、時々プログラムのテストを行いたいです。一度、Pythonインタプリタでモジュールを小さく区切って新しいコードをテストするためにプログラムを記述します。

import myModule
myModule.myTestFunction()

しかし、myTestFunction()関数が正しく動作しませんか？エディタに戻って修正します。そのとき、Pythonインタプリタを一度閉じて再度開くと簡単にモジュールを更新することができます。

reload(myModule)

FreeCADではじめる

Pythonのプログラムを作るためのアイデアが理解できた思います。そして、FreeCADがどのようなモジュールを提供しているか探し始めることができます。 FreeCADのPython関数は、すべてが異なるモジュールに整理されています。FreeCADを起動したときにそれらのいくつかはすでにロード（インポート）されます。だから、使うだけです。

dir()

ここを参照してくださいFreeCADの基本スクリプト...

もちろん、ここではPythonの世界のごく一部を見ました。ここでは言及しなかったことで、多くの重要な概念があります。ネット上には2つの非常に重要なPythonのリファレンスドキュメントがあります：

• Python公式リファレンス
• Dive into Python wikiブック

これらをブックマークしてください！

FreeCADでのPythonによるスクリプト処理

FreeCADはPythonスクリプトで完全に操作できるように一から作られています。FreeCADのほとんどの部分、インターフェースやシーンの内容、そして３Dビューで表示される内容でさえも、内蔵のPythonインタプリタや自作のスクリプトからアクセスすることができます。このためFreeCADは現在利用できるエンジニアリング用アプリケーションの中でも、とことんカスタマイズ可能なアプリの一つでしょう。

しかしいまのところ、３Dオブジェクトを操作するための'ネィティブ'コマンドはほんの僅かしかありません。これは開発がいまだ初期段階であるということだけではなく、アプリケーションとしての特定の利用よりもCAD開発のためのプラットフォームを提供すること背景にある設計思想として優先しているからです。しかしFreeCADのpythonスクリプトは簡単なので、パワーユーザーやpythonプログラムを少しかじったことのあるユーザーが開発中の新しい機能を素早く調べる上で、大きな手助けとなるでしょう。Pythonは最も人気のあるインタプリタ言語の一つで、それは学ぶのが簡単であると言われているためでもあります。あなたもすぐに独自のFreeCAD'パワーユーザー'スクリプトを作成できる様になるでしょう。

もしPythonに慣れていなければ、インターネット上でチュートリアルを検索することをお勧めします。まずはPythonの構造をざっと見ることです。Pythonはとても簡単に学ぶことのできる言語で、これは特にインタプリタで実行できることが大きいでしょう。単純なコマンドから完全なプログラムまで、一切コンパイルする必要がなく、その場で実行することができるのです。FreeCADは内蔵のpythonインタプリタを持っています。もし以下に示すような"Python console"という名前のウインドウが見つからなければ、View -> Views -> Python consoleからインタプリタを起動してください。

インタプリタ

インタプリタから、システムにインストールされている全てのPythonモジュールにアクセスすることができます。また内蔵のFreeCADモジュールや、後から追加インストールしたFreeCADモジュールへもアクセスが可能です。次のスクリーンショットはPythonインタプリタです。

インタプリタではPythonコードの実行と利用可能なクラスや関数の閲覧が可能です。またFreeCADはFreeCADの新世界を探索するためのとても便利なクラスブラウザを提供しています。既知のクラス名に続いてピリオドをタイプすると（これはそのクラスから何かを追加するという意味です）、クラスブラウザウインドウが開き、利用可能なサブクラスとメソッドをナビゲートすることができます。ここで何かを選択すると関連するヘルプテキストが（ある場合ですが）表示されます。

ではGui. やApp. をタイプして何が起こるのか見てください。モジュールやクラスの内容を調べるもう一つのより一般的な方法は、print dir()コマンドを使うことです。たとえば、print dir() とタイプすると、現在FreeCADで読み込まれている全てのモジュールをリストします。print dir(App) はAppモジュールに含まれている全ての内容を表示します。

インタプリタのもう一つの便利な機能は、コマンドの履歴を遡ることができ、前に入力したコードの行を取り出せることです。コマンドの履歴の移動は、Ctrl+上、またはCtrl+下です。

インタプリタウインドウ内での右クリックで、全てのコマンド履歴のコピー（完全なスクリプトを作成する前に処理を試したい場合に便利です）や、ファイルの絶対パスの挿入などの複数のオプションが利用できます。

pythonのヘルプ

FreeCADのヘルプメニューには”Python help”という名前のついた項目があり、FreeCADで利用可能な全てのPythonモジュールについての、リアルタイムで生成された完全なドキュメントを持ったブラウザが開きます。これには、Python、FreeCAD内蔵モジュール、システムにインストール済みのモジュール、そしてFreeCADの追加モジュールのドキュメントが含まれます。利用できるドキュメントは、各モジュールの開発者が自分のコードにどれだけドキュメントを入れる努力をしているかによりますが、ほとんどの場合、pythonモジュールはかなりよくドキュメント化されていると定評があります。このドキュメントのシステムを利用するためには、FreeCADウインドウを開いたままにする必要があります。

内蔵モジュール

FreeCADは、グラフィカルユーザーインターフェース抜きでも実行できるように設計されているため、ほとんど全ての機能が2つのグループに分けられています。Appと名づけられたコアとなる機能と、Guiと名づけられたGUIの機能です。このため、２つの主要な内蔵モジュールはAppとGuiと呼ばれています。この2つのモジュールは内蔵インタプリタ外部のスクリプトからも、FreeCADとFreeCADGuiという名前でそれぞれアクセスできます。

• Appモジュール では、アプリケーション自身に関連する全ての内容が見つかります。ファイルやドキュメントのオープンとクローズのメソッドや、アクティブなドキュメントの設定、その内容のリスト化などです。

• GUIモジュール では、Guiの構成要素の管理とアクセスのためのツールが見つかります。ワークベンチとそのツールバーや、より興味深い、FreeCADの全内容のグラフィカル表現です。

モジュールの内容を全てリストにするのはFreeCADの開発に伴いその内容も急増していくので少々非生産的な仕事です。しかし提供されている２つの閲覧ツール（クラスブラウザとpythonヘルプ）でいつでもモジュールの最新の完全なドキュメントを得られるはずです。

AppとGuiオブジェクト

先ほど述べたように、FreeCADの全ての機能はコアと表現に別れています。これには3Dオブジェクトも含まれています。Appモジュールを介してオブジェクトのプロパティ定義（FreeCADで機能と呼ばれるもの）にアクセスすることができ、そしてGuiモジュールを介してそれらのスクリーン上での表現方法を変えることができます。たとえば立方体はそれを定義するプロパティである長さや幅、高さなどを持ち、これらはAppオブジェクトに格納されています。また表現のプロパティである、面の色や描画方法などは対応するGuiオブジェクトに格納されています。

このようなやり方は、視覚的な部分をまったく気にすることなくアルゴリズムをその機能の定義部分でのみ動作するようにさせたり、ドキュメントの内容をリストやスプレッドシートや要素解析などのノングラフィカルなアプリケーションへ出力するなどの、幅広い利用を可能にしています。

ドキュメント内のどのAppオブジェクトも対応するGuiオブジェクトが存在します。ドキュメントそれ自体も実際にはAppとGuiオブジェクトを持っています。これはもちろんFreeCADを完全なインターフェイスで実行したときに有効になります。コマンドラインバージョンではGUIが存在しないのでAppオブジェクトのみが利用できます。オブジェクトのGui部分はAppオブジェクトが"再計算する"とマークされたときに再び生成されます（例えばパラメータがひとつ変更された時）、そのためGuiオブジェトに対して直接行った操作が消えてしまう可能性があることに注意してください。

App部分にアクセスするためには、次のように入力します。

myObject = App.ActiveDocument.getObject（"ObjectName"）

ここで"ObjectName"はオブジェクトの名前です。また次のように入力することもできます。

myObject = App.ActiveDocument.ObjectName

同じオブジェクトのGUI部分へアクセスするには、次のように入力します。

myViewObject=Gui.ActiveDocument.getObject（"ObjectName"）

ここで"ObjectName"はオブジェクトの名前です。また次のように入力することもできます。

myViewObject = App.ActiveDocument.ObjectName.ViewObject

GUIを持っていない場合には（例えばコマンドラインモード）、最後の行はNoneが帰ってきます。

ドキュメントオブジェクト

FreeCAD上であなたが行った全ての内容はドキュメントの中に存在しています。ドキュメントはジオメトリを持ち、ファイルに保存することができます。また複数のドキュメントを同時に開くこともできます。ドキュメントはジオメトリと同じくAppやGUIオブジェクトを内部に持っています。Appオブジェクトには実際のジオメトリ定義が含まれていますが、一方でGUIオブジェクトはドキュメントのさまざまなビューを含んでいます。あなたは複数のウインドウを開き、そのそれぞれで異なる倍率や視点でビューを表示することができます。これらのビューは全てドキュメントのGUIオブジェクトの一部です。

現在開いている（アクティブな）ドキュメントのApp部分にアクセスするには次のように入力します。

myDocument = App.ActiveDocument

新しいドキュメントを作成するには次のように入力します。

myDocument = App.newDocument（"Document Name"）

現在開いている（アクティブな）ドキュメントのGui部分にアクセスするには次のように入力します。

myGuiDocument = Gui.ActiveDocument

現在のビューにアクセスするには次のように入力します。

myView = Gui.ActiveDocument.ActiveView

追加モジュールの使用

FreeCADモジュールとFreeCADGuiモジュールが果たす役割はFreeCADドキュメントでのオブジェクトの作成と管理だけです。これらのモジュールはジオメトリーの作成や変更といった処理は全く行いません。ジオメトリーの種類は複数にわたり、それらはそれぞれの特定のジオメトリー型の管理に特化した追加モジュールによって管理されるためです。例えばパートモジュール はOpenCascadeカーネルを使用してOpenCascadeが作成された目的であるところのB-rep型ジオメトリーの作成と操作を行うことができます。メッシュモジュールはメッシュオブジェクトの作成と変更を行うことができます。この様にFreeCADは幅広い種類のオブジェクト型を扱うことができ、それらを同じドキュメント内で同時に保持することができます。また今後も新しい型を簡単に追加していくことができるのです。

オブジェクトの作成

各モジュールはそれぞれの方法でジオメトリーを取り扱いますが一つだけ全てのモジュールで行うことのできる処理があります。ドキュメント内でのオブジェクトの作成です。一方でFreeCADドキュメントの方でもモジュールによって提供される利用可能なオブジェクト型を認識することができます：

FreeCAD.ActiveDocument.supportedTypes()

上記を行うと作成することのできる全てのオブジェクトがリストアップされます。例としてメッシュ（メッシュモジュールによって扱われます）とパート（パートモジュールによって扱われます）を作ってみましょう：

myMesh = FreeCAD.ActiveDocument.addObject("Mesh::Feature","myMeshName")
myPart = FreeCAD.ActiveDocument.addObject("Part::Feature","myPartName")

一つ目の引数はオブジェクトの型で、二つ目の引数はオブジェクトの名前です。作成した二つのオブジェクトはほとんど同じように見えます。ジオメトリーはまだ設定されておらず、dir(myMesh)やdir(myPart)で調べるとそのプロパティはほとんど同じです。一つだけ異なるのはmyMeshには"Mesh"プロパティがあり、"Part"には"Shape"プロパティがあることです。これがメッシュやパートのデータが保存される場所です。例として立方体パートを作成してmyPartオブジェクトに設定してみましょう：

import Part
cube = Part.makeBox(2,2,2)
myPart.Shape = cube

試しにcubeをmyMeshのMeshプロパティに設定してみてください。は間違った型である、というエラーメッセージでエラーが返されるはずです。これらのプロパティは特定の型のみ設定できるように作られているからです。myMeshのMeshプロパティにはMeshモジュールで作成したインスタンスしか保存できないのです。またほとんどのモジュールにはドキュメントにそのジオメトリーを追加するためのシュートカットがあることを憶えておいてください。

import Part
cube = Part.makeBox(2,2,2)
Part.show(cube)

オブジェクトの変更

オブジェクトの変更も同じように行います：

import Part
cube = Part.makeBox(2,2,2)
myPart.Shape = cube

それではもう少し形状を大きく変更しましょう：

biggercube = Part.makeBox(5,5,5)
myPart.Shape = biggercube

オブジェクトの問い合わせ処理

以下のようにするといつでもオブジェクトの型を見ることができます：

myObj = FreeCAD.ActiveDocument.getObject("myObjectName")
print myObj.Type

またオブジェクトが基本オブジェクト（Part FeatureやMesh Featureなど）から継承されたものかどうか調べるには以下のようにします：

 print myObj.isDerivedFrom("Part::Feature")

さあ、これで本当にFreeCADで遊び始めることができます！パートモジュールを使って何ができるかについてはパートのスクリプト処理ページを、 メッシュモジュールを使った作業についてはメッシュのスクリプト処理ページを読んでください。パートモジュールやメッシュモジュールはほぼ完成して幅広く使用されていますが、製図モジュールなどの他のモジュールにも便利なスクリプト処理用APIがあることを憶えておいてください。各モジュールの完全なリストとそこで利用可能なツールについてはCategory:API/jpセクションを見てください。

はじめに

まず、メッシュモジュールをインポートする必要があります:

import Mesh

これで、FreeCADのC++ Meshカーネルの関数を容易に使うことができるMeshモジュールとMeshクラスへのアクセス権限があります。

作成と読み込み

空のメッシュオブジェクトを作成するには、標準のコンストラクタを使用します。

mesh = Mesh.Mesh()

また、ファイルからオブジェクトを作成することができます

mesh = Mesh.Mesh('D:/temp/Something.stl')

（互換性のあるファイルタイプのリストは'Meshes'で見ることができます。ここ） または頂点座標で記述された三角形の集合体から作成します。

planarMesh = [
# triangle 1
[-0.5000,-0.5000,0.0000],[0.5000,0.5000,0.0000],[-0.5000,0.5000,0.0000],
#triangle 2
[-0.5000,-0.5000,0.0000],[0.5000,-0.5000,0.0000],[0.5000,0.5000,0.0000],
]
planarMeshObject = Mesh.Mesh(planarMesh)

メッシュカーネルは、一致する点やエッジをソートすることによってトポロジー的に正しいデータ構造を作成する手助けをします。

後でメッシュデータを表示してテストし、メッシュデータを調べることができます。

モデリング

PythonスクリプトのBuildRegularGeoms.pyを使用すると、正常なジオメトリを作成することができます。

import BuildRegularGeoms

このスクリプトは、球・楕円・円柱・ドーナツ形・円錐と同様にシンプルな回転体を定義するためのメソッドを提供します。そしてそれはまた、単純な立方体を作成するためのメソッドを持っています。 ドーナツ形状を作成するには、例えば以下のように行うことができます。

t = BuildRegularGeoms.Toroid(8.0, 2.0, 50) # list with several thousands triangles
m = Mesh.Mesh(t)

最初の2つのパラメータはドーナツ形の半径を定義し、3番目のパラメータは形状を構成する三角形状のサブサンプリング係数です。この値が高いほど、より滑らかになり、低いと粗くなります。 Meshクラスは、モデリングの目的で使用できるブール関数のセットを提供します。それは、和・積と2つのメッシュオブジェクトの差を提供します。

m1, m2              # are the input mesh objects
m3 = Mesh.Mesh(m1)  # create a copy of m1
m3.unite(m2)        # union of m1 and m2, the result is stored in m3
m4 = Mesh.Mesh(m1)
m4.intersect(m2)    # intersection of m1 and m2
m5 = Mesh.Mesh(m1)
m5.difference(m2)   # the difference of m1 and m2
m6 = Mesh.Mesh(m2)
m6.difference(m1)   # the difference of m2 and m1, usually the result is different to m5

最後に、その完全な例は、球とシリンダの交点を計算します。

import Mesh, BuildRegularGeoms
sphere = Mesh.Mesh( BuildRegularGeoms.Sphere(5.0, 50) )
cylinder = Mesh.Mesh( BuildRegularGeoms.Cylinder(2.0, 10.0, True, 1.0, 50) )
diff = sphere
diff.difference(cylinder)
d = FreeCAD.newDocument()
d.addObject("Mesh::Feature","Diff_Sphere_Cylinder").Mesh=diff
d.recompute()

調査とテスト

独自のアルゴリズムを書く

エクスポート

Pythonのモジュールにメッシュを書くことができます：

m.write("D:/Develop/Projekte/FreeCAD/FreeCAD_0.7/Mod/Mesh/SavedMesh.py")
import SavedMesh
m2 = Mesh.Mesh(SavedMesh.faces)

GUI関連

雑記

メッシュ関連スクリプトの広範な（ハードな使い方）のソースは、メッシュモジュールのユニットテストスクリプトです。 このユニットテストでは文字通りすべてのメソッドが呼び出され、すべてのプロパティ/属性が微調整されています。 そして十分な情報がほしいときは、Unit Test moduleを見てください。

このページではpythonからPart形状を作成・変更する複数の方法について説明しています。もしpythonを初めて使うのであればこのページを読む前にpythonのスクリプト処理とFreeCADでpythonのスクリプト処理がどの様に動作するのかについて読むことをお勧めします。

はじめに

FreeCADのpythonインタプリタや外部のスクリプトから、直接、Partモジュールを操作する方法を説明します。まず スクリプティングを参照してください。FreeCADでのpythonスクリプトの方法についてより詳しい情報が必要な場合は FreeCADスクリプトの基本ページを参照してください。

クラス・ダイアグラム

これはPartモジュールの最も重要なクラスに関するUML (Unified Modeling Language)の概要図です：

ジオメトリー

ジオメトリーオブジェクトは、トポロジーオブジェクトを構成するための基本要素です：

• Geom ジオメトリーオブジェクトの基底クラスです。
• Line 始点と終点で定義された3次元の直線です。
• Circle 中心と始点と終点で定義される円や円の断片です。
• ...... じきに増えるでしょう;-)

トポロジー

次の種類のトポロジーのデータが利用できます：

• Compound 任意の種類のトポロジーオブジェクトのグループです。
• Compsolid ソリッドの合成とは、フェイスで接続するソリッドの集合です。ワイヤとシェルの概念をソリッドへ拡張したものです。
• Solid（ソリッド） シェルで区切られた空間です。3次元です。
• Shell（シェル） エッジで接続しているフェイスの集合です。シェルは開閉できます。
• Face（フェイス） 2次元では平面の一部分、3次元では表面の一部分です。形状は輪郭線で律則されています（切り取られています）。2次元です。
• Wire（ワイヤ） 頂点で接続するエッジの集合です。エッジの接続に応じて、輪郭線は開閉します。
• Edge（エッジ） 制約された曲線に対応する位相要素です。エッジは一般的に頂点によって律則されます。1次元です。
• Vertex（頂点） 点に対応するトポロジーの要素です。0次元です。
• Shape（シェイプ） 上記全ての一般的な総称です 。

クイックサンプル：シンプルなトポロジーの作成

単純なジオメトリーからトポロジーを構築して作成しましょう。 サンプルでは画像に示す四つの頂点と二つの円と二本のラインからできたパーツを使用します。

ジオメトリーの作成

まずこのワイヤーの特徴的なジオメトリーパーツを作成しなければなりません。 また頂点のジオメトリーパーツが同じ位置に置かれるように注意する必要があります。 さもないと後でジオメトリーパーツをつなげてトポロジーにすることができなくなってしまいます！

さあ、まず点を作成します：

from FreeCAD import Base
V1 = Base.Vector(0,10,0)
V2 = Base.Vector(30,10,0)
V3 = Base.Vector(30,-10,0)
V4 = Base.Vector(0,-10,0)

円弧

円弧を作成するために補助点を作成し、三つの点を通る円弧を作成します：

VC1 = Base.Vector(-10,0,0)
C1 = Part.Arc(V1,VC1,V4)
# 2番目の円弧
VC2 = Base.Vector(40,0,0)
C2 = Part.Arc(V2,VC2,V3)

ライン

ラインはシンプルに点から作成できます：

L1 = Part.Line(V1,V2)
# and the second one
L2 = Part.Line(V4,V3)

一つにまとめる

最後のステップとしてジオメトリーベースの要素をまとめ、トポロジカルな形状に固定します：

S1 = Part.Shape([C1,C2,L1,L2])

プリズムの作成

さてワイヤーを一定の方向に押し出して実際の3D形状を作成します：

W = Part.Wire(S1.Edges)
P = W.extrude(Base.Vector(0,0,10))

全体の表示

Part.show(P)

基本的な形状の作成

Partモジュールの"make ...()"メソッドを使って、簡単に基本的なトポロジーオブジェクトを作成することができます。

b=Part.makeBox(100,100,100)
Part.show(b)

使用可能な他のmake...()メソッドです：

• makeBox(l,w,h): 寸法が(l,w,h)で位置pからd方向を指す箱を作ります。
• makeCircle(radius): 指定した半径の円を作ります。
• makeCone(radius1,radius2,height): 指定した半径と高さの円錐を作成します。
• makeCylinder(radius,height): 指定した半径と高さを持つ円柱を作成します。
• makeLine((x1,y1,z1),(x2,y2,z2)): 二点間を結ぶ線を作成します。
• makePlane(length,width): 指定した幅と長さの平面を作成します。
• makePolygon(list): 点のリストからポリゴンを作成します。
• makeSphere(radius): 指定された半径の球を作成します。
• makeTorus(radius1,radius2): 指定した半径のトーラスを作ります。

Partモジュールで利用可能な全てのメソッドのリストについてはPart APIのページを見てください。

必要なモジュールのインポート

まずPartモジュールをインポートする必要があります。インポートを行うとその中身をpythonで使用できるようになります。 またFreeCADモジュール内にあるBaseモジュールもインポートします：

import Part
from FreeCAD import Base

頂点を作るには？

ベクトルは形状を作成する際に最も重要な情報の一つです。通常はデカルト座標のx、y、z、3つの数字を含みます（ただし必ずしも常にそうであるわけではありません）。次の様にするとベクトルが作成されます：

myVector = Base.Vector(3,2,0)

座標 x=3、y=2、z=0にベクトルを作成しました。Partではいろいろな場所でベクトルが使われています。 Partの形状ではVertex（頂点）と呼ばれる別の点表現も使用されています。これは実際の所はベクトル用のコンテナ 以外の何物でもありません。頂点のベクトルには次のようにしてアクセスします：

myVertex = myShape.Vertexes[0]
print myVertex.Point
> Vector (3, 2, 0)

エッジを作るには？

エッジとは2つの頂点からなる線に他なりません：

edge = Part.makeLine((0,0,0), (10,0,0))
edge.Vertexes
> [<Vertex object at 01877430>, <Vertex object at 014888E0>]

注意: 二つのベクトルを渡してエッジを作成することもできます：

vec1 = Base.Vector(0,0,0)
vec2 = Base.Vector(10,0,0)
line = Part.Line(vec1,vec2)
edge = line.toShape()

エッジの長さと中心は次のようにするとわかります：

edge.Length
> 10.0
edge.CenterOfMass
> Vector (5, 0, 0)

画面上に形状を配置

さて今までエッジオブジェクトを作成して来ましたが画面上には何も表示されません。 これは今まではたんにpythonのオブジェクトを操作してきただけだからです。 FreeCADの3Dシーンは表示するように指示された場合にだけ表示されます。 これを行うには次の簡単なメソッドを使用します：

Part.show(edge)

FreeCADドキュメント内にオブジェクトが作成され、そのオブジェクトによって私たちの"エッジ"形状が設定されます。 作成したものを画面に表示する場合には常にこれを使用します。

ワイヤを作るには？

ワイヤとは複数のエッジでエッジのリスト、またはワイヤのリストから作成することができます：

edge1 = Part.makeLine((0,0,0), (10,0,0))
edge2 = Part.makeLine((10,0,0), (10,10,0))
wire1 = Part.Wire([edge1,edge2]) 
edge3 = Part.makeLine((10,10,0), (0,10,0))
edge4 = Part.makeLine((0,10,0), (0,0,0))
wire2 = Part.Wire([edge3,edge4])
wire3 = Part.Wire([wire1,wire2])
wire3.Edges
> [<Edge object at 016695F8>, <Edge object at 0197AED8>, <Edge object at 01828B20>, <Edge object at 0190A788>]
Part.show(wire3)

Part.show(wire3)はワイヤーを構成する4つの線を表示します。他にも有用な情報を簡単に取得することができます：

wire3.Length
> 40.0
wire3.CenterOfMass
> Vector (5, 5, 0)
wire3.isClosed()
> True
wire2.isClosed()
> False

フェイスを作るには？

正しいフェイスは閉じたワイヤのみから作成することができます。 この例では、wire3は閉じたワイヤですが、wire2（上記参照）は閉じていません。

face = Part.Face(wire3)
face.Area
> 99.999999999999972
face.CenterOfMass
> Vector (5, 5, 0)
face.Length
> 40.0
face.isValid()
> True
sface = Part.Face(wire2)
face.isValid()
> False

フェイスは面積を持ちますが、ワイヤやエッジは面積を持ちません。

円を作るには？

円はこのようにシンプルに作成することができます：

circle = Part.makeCircle(10)
circle.Curve
> Circle (Radius : 10, Position : (0, 0, 0), Direction : (0, 0, 1))

位置と方向をもった円を作るにはこのように書きます。

ccircle = Part.makeCircle(10, Base.Vector(10,0,0), Base.Vector(1,0,0))
ccircle.Curve
> Circle (Radius : 10, Position : (10, 0, 0), Direction : (1, 0, 0))

ccircleは、xの原点からの距離が10で、x軸を向くように作成されています。 注：makeCircleは、位置と法線として、タプルではなくBase.Vector()のみを受けとります。 また開始角と終了角を与えることによって、円の一部を作成することができます：

from math import pi
arc1 = Part.makeCircle(10, Base.Vector(0,0,0), Base.Vector(0,0,1), 0, 180)
arc2 = Part.makeCircle(10, Base.Vector(0,0,0), Base.Vector(0,0,1), 180, 360)

arc1とarc2の両方を合わせると円になります。 角度は度単位で指定する必要があります。ラジアンが必要な場合は次の様に変換することができます。 degrees = radians * 180/PI またはpythonの数学モジュールを使用します（import mathが必要です）：

degrees = math.degrees(radians)

点に通る弧を作るには？

残念ながらmakeArc関数はありませんが、三点を通る弧を作成するPart.Arc関数があります。 この関数は、基本的には、中間点を通って開始点と終了点を結ぶ弧を仮定しています。 Part.Arcは弧オブジェクトを作成します。弧オブジェクトからエッジオブジェクトを作成するには.toShape()を呼びます。 これはPart.makeLineの代わりにPart.Lineを使用した時と同じです。

arc = Part.Arc(Base.Vector(0,0,0),Base.Vector(0,5,0),Base.Vector(5,5,0))
arc
> <Arc object>
arc_edge = arc.toShape()

注意：Arcは点としてタプルではなくBase.Vector()のみを受け取ります。 arc_edgeはPart.show(arc_edge)によって表示することができます。 円弧として円の一部を使用することも可能です：

from math import pi
circle = Part.Circle(Base.Vector(0,0,0),Base.Vector(0,0,1),10)
arc = Part.Arc(c,0,pi)

円弧はラインと同じようにエッジです。従ってこの方法はワイヤーに対しても使用することができます。

ポリゴンを作るには？

ポリゴンは複数の真っ直ぐなエッジからできたワイヤーに他なりません。 makePolygon関数は点のリストを受け取り、その点を通る線を作成します：

lshape_wire = Part.makePolygon([Base.Vector(0,5,0),Base.Vector(0,0,0),Base.Vector(5,0,0)])

平面を作るには？

平面は平坦な表面です。作成するためのメソッドはmakePlane(length,width,[start_pnt,dir_normal])です。 初期値はstart_pnt=Vector(0,0,0)とdir_normal=Vector(0,0,1)です。 dir_normal=Vector(0,0,1)はz軸に面した平面を作成します。 dir_normal=Vector(1,0,0)はx軸に面した平面を作成します。

plane = Part.makePlane(2,2)
plane
><Face object at 028AF990>
plane = Part.makePlane(2,2, Base.Vector(3,0,0), Base.Vector(0,1,0))
plane.BoundBox
> BoundBox (3, 0, 0, 5, 0, 2)

BoundBoxは、その対角線が（3,0,0）から始まり（5,0,2)で終わる平面を囲む直方体です。 このBoundBoxのy軸の厚さはゼロです。 注：makePlaneは、start_pntとdir_normalとしてタプルではなくBase.Vector()のみを受け取ります。

楕円を作るには？

楕円の作成にはいくつかの方法があります：

Part.Ellipse()

中心が(0,0,0)で、大半径2と小半径1の楕円を作成します。

Part.Ellipse(Ellipse)

楕円のコピーを作成します。

Part.Ellipse(S1,S2,Center)

点Centerを中心とする楕円を作成します。 楕円平面は、Center、S1とS2で定義されています。 主軸はCenterとS1で定義されています。 長径はCenterとS1の間の距離です 短径はS2と主軸との距離です。

Part.Ellipse(Center,MajorRadius,MinorRadius)

長径MajorRadius、短径MinorRadiusの楕円を作成し、 Centerと法線(0,0,1)で定義された平面上に配置します。

eli = Part.Ellipse(Base.Vector(10,0,0),Base.Vector(0,5,0),Base.Vector(0,0,0))
Part.show(eli.toShape())

上記のコードでは、S1、S2、および中心を渡しています。 Arcと同様に、Ellipseも楕円オブジェクトを作りますが、エッジは作成しません。 このため、楕円を表示するためにはtoShape()を使い、エッジに変換する必要があります。

注意：Arcはタプルではなく、Base.Vector()のみを受け取ります。

eli = Part.Ellipse(Base.Vector(0,0,0),10,5)
Part.show(eli.toShape())

上記のEllipseのコンストラクタでは、中心座標、MajorRadius、MinorRadiusを渡しています。

トーラスを作るには？

makeTorus(radius1,radius2,[pnt,dir,angle1,angle2,angle])を使用します。 初期値は、pnt=Vector(0,0,0)、dir=Vector(0,0,1)、angle1=0、angle1=360、angle=360です。 トーラスは小さな円が、大きな円に沿ってスイープしているものと考えます。 radius1は大きい円の半径、radius2は小さい円の半径です。 pntはトーラスの中心、dirは法線方向です。 angle1とangle2は小さな円のラジアンの角度です。 最後のパラメータangleはトーラスの一部を作成するためのものです：

torus = Part.makeTorus(10, 2)

上記のコードは、直径20（半径10）と厚さ4（小さい円の半径2）のトーラスを作成します。

tor=Part.makeTorus(10,5,Base.Vector(0,0,0),Base.Vector(0,0,1),0,180)

上記のコードはトーラスのスライスを作成します。

tor=Part.makeTorus(10,5,Base.Vector(0,0,0),Base.Vector(0,0,1),0,360,180)

上記のコードは半分のトーラスを作成します。このコードでは最後のパラメータが変更されただけで、あとの角度は初期値のままです。 角度へ180与えた結果、0から180、つまり半分のトーラスを作成します。

ボックスまたは直方体を作るには？

makeBox(length,width,height,[pnt,dir])を使用します。 初期値はpnt=Vector(0,0,0)、dir=Vector(0,0,1)です。

box = Part.makeBox(10,10,10)
len(box.Vertexes)
> 8

球を作るには？

makeSphere(radius,[pnt, dir, angle1,angle2,angle3])を使用します。 初期値はpnt=Vector(0,0,0)、dir=Vector(0,0,1)、angle1=-90、angle2=90、angle3=360です。 angle1とangle2は、球の垂直方向の最小値と最大値です。 angle3は球の直径です。

sphere = Part.makeSphere(10)
hemisphere = Part.makeSphere(10,Base.Vector(0,0,0),Base.Vector(0,0,1),-90,90,180)

円柱を作るには？

makeCylinder(radius,height,[pnt,dir,angle])を使用します。 初期値は、pnt=Vector(0,0,0)、dir=Vector(0,0,1)、angle=360=ベクトルです。

cylinder = Part.makeCylinder(5,20)
partCylinder = Part.makeCylinder(5,20,Base.Vector(20,0,0),Base.Vector(0,0,1),180)

円錐を作るには？

makeCone(radius1,radius2,height,[pnt,dir,angle])を使用します。 初期値は、pnt=Vector(0,0,0)、dir=Vector(0,0,1)、angle=360=ベクトルです。

cone = Part.makeCone(10,0,20)
semicone = Part.makeCone(10,0,20,Base.Vector(20,0,0),Base.Vector(0,0,1),180)

シェイプの変更

形状を変更するには複数の方法があります。移動や回転などの簡単な変換操作もありますが 他の形状との結合や減算などの複雑などのもっと複雑なものもあります。

変換操作

シェイプの移動

移動は形状をある場所から別の場所に動かす操作です。 任意の形状（エッジ、フェイス、立方体など）を同じ方法で移動させることができます：

myShape = Part.makeBox(2,2,2)
myShape.translate(Base.Vector(2,0,0))

ここでは"myShape"を2単位分、X方向に移動させています。

シェイプの回転

形状を回転させるには回転中心、軸、回転角を指定する必要があります：

myShape.rotate(Vector(0,0,0),Vector(0,0,1),180)

上記のコードでは形状をZ軸の周りに180度回転させています。

行列を使用した一般的な変換

行列は3D空間での変換操作を保持する際に非常に便利です。 一つの行列に対してオブジェクトに適用する移動、回転、拡大縮小の値を設定することができるのです。 例えば次のようにします：

myMat = Base.Matrix()
myMat.move(Base.Vector(2,0,0))
myMat.rotateZ(math.pi/2)

注意：FreeCADの行列はラジアン単位で動作します。またほとんどのベクトルを引数に持つ行列操作は 3つの数値を引数に取ることもできます。従って以下の2行は同じ処理を行います：

myMat.move(2,0,0)
myMat.move(Base.Vector(2,0,0))

行列が設定されるとそれを形状に対して適用できるようになります。FreeCADではそれを行うための 2つのメソッドが用意されています。transformShape()とtransformGeometry()です。違いは一つ目のメソッド では行列の変形が行われないということです（下記の"シェイプの拡大縮小"を参照）。 変換は以下のようにして適用します：

myShape.trasformShape(myMat)

または

myShape.transformGeometry(myMat)

シェイプの拡大縮小

形状の拡大縮小は危険な操作です。なぜなら移動や回転と異なり拡大縮小は非一様（x、y、zで異なる値を使って） に形状の構造を変更することができるからです。例えば垂直方向よりも水平方向に大きな値を使って円を 変換すれば楕円になり、楕円は円とは数学的に全く異なった振る舞いをします。拡大縮小では transformShape()を使うことはできず、transformGeometry()を使わなければなりません：

myMat = Base.Matrix()
myMat.scale(2,1,1)
myShape=myShape.transformGeometry(myMat)

ブーリアン演算

あるシェイプを他のシェイプからカットするには？

ある形状から別の形状を取り除くことをOCC/FreeCADでは"カット"と呼び、次のようにして行います：

cylinder = Part.makeCylinder(3,10,Base.Vector(0,0,0),Base.Vector(1,0,0))
sphere = Part.makeSphere(5,Base.Vector(5,0,0))
diff = cylinder.cut(sphere)

2つのシェイプ間の積を得るには？

同じように2つの形状の交差は"コモン"と呼び、次のようにして行います：

cylinder1 = Part.makeCylinder(3,10,Base.Vector(0,0,0),Base.Vector(1,0,0))
cylinder2 = Part.makeCylinder(3,10,Base.Vector(5,0,-5),Base.Vector(0,0,1))
common = cylinder1.common(cylinder2)

２つのシェイプ間の和をとるには？

結合は"フューズ"と呼ばれ、同じようにして行うことができます：

cylinder1 = Part.makeCylinder(3,10,Base.Vector(0,0,0),Base.Vector(1,0,0))
cylinder2 = Part.makeCylinder(3,10,Base.Vector(5,0,-5),Base.Vector(0,0,1))
fuse = cylinder1.fuse(cylinder2)

ソリッドを与えられたシェイプで切断するには？

セクションはソリッド形状と平面形状の間での交差です。 エッジで構成された交差曲線を返します：

cylinder1 = Part.makeCylinder(3,10,Base.Vector(0,0,0),Base.Vector(1,0,0))
cylinder2 = Part.makeCylinder(3,10,Base.Vector(5,0,-5),Base.Vector(0,0,1))
section = cylinder1.section(cylinder2)
section.Wires
> []
section.Edges
> [<Edge object at 0D87CFE8>, <Edge object at 019564F8>, <Edge object at 0D998458>, 
 <Edge  object at 0D86DE18>, <Edge object at 0D9B8E80>, <Edge object at 012A3640>, 
 <Edge object at 0D8F4BB0>]

押し出しを行うには？

押し出しは平面形状を一定方向に"押し出す"ことでソリッドボディーを作成する操作です。 "押し出し"によって円が管になるのを想像してください：

circle = Part.makeCircle(10)
tube = circle.extrude(Base.Vector(0,0,2))

もし円が中空であれば中空の管が得られ、円が実際には円盤、 つまり面で埋まっていればソリッドな円柱が得られます。

wire = Part.Wire(circle)
disc = Part.makeFace(wire)
cylinder = disc.extrude(Base.Vector(0,0,2))

シェイプを調査する

トポロジーのデータ構造は簡単に調べることができます：

import Part
b = Part.makeBox(100,100,100)
b.Wires
w = b.Wires[0]
w
w.Wires
w.Vertexes
Part.show(w)
w.Edges
e = w.Edges[0]
e.Vertexes
v = e.Vertexes[0]
v.Point

上記の内容をPythonインタープリタに入力することで、Partオブジェクトの構造をよく理解することができます。ここでmakeBox()コマンドはソリッド形状を作成します。このソリッドはすべてのPartソリッドと同様に複数のフェイスを含んでいます。フェイスは常にその境界となるエッジのリストであるワイヤーを持ちます。各フェイスは少なくとも1つの閉じたワイヤーを持ちます（フェイスが穴の場合は複数のワイヤーを持ちます）。ワイヤーでは各エッジを別々に調べることができ、またそのエッジでは各頂点を調べることができます。直線のエッジは当然2つの頂点のみを持っています。

エッジを調査する

エッジの場合、エッジは任意の曲線であるので、おそらく離散化したいと思うでしょう。FreeCADでは、エッジはその長さによってパラメータ化されています。つまりその長さでエッジ/曲線を操作できるということです：

import Part import Part
box = Part.makeBox(100,100,100)
anEdge = box.Edges[0]
print anEdge.Length

この長さを位置として使用して多くのエッジのプロパティにアクセスすることができます。つまりエッジ長が100mmであれば、エッジの開始位置は0で終了位置は100であるということです。

anEdge.tangentAt(0.0) # 初期の接線方向です
anEdge.valueAt(0.0) # エッジの開始点です
anEdge.valueAt(100.0) # エッジの終点です
anEdge.derivative1At(50.0) #　中点での曲線の一次導関数です
anEdge.derivative2At(50.0) # 中点での曲線の二次導関数です
anEdge.derivative3At(50.0) # 中点での曲線の三次導関数です
anEdge.centerOfCurvatureAt(50) # この位置の曲率中心です
anEdge.curvatureAt（50.0）# 曲率です
anEdge.normalAt(50) # この位置の法線です（定義されている場合）

選択機能を使う

ここではユーザがビューア上で行う選択操作を使用する方法についてみていきます。 まず最初にボックスを作成しそれをビューアで表示します

import Part
Part.show(Part.makeBox(100,100,100))
Gui.SendMsgToActiveView("ViewFit")

フェイスかエッジを選択します。このスクリプトを使うと 全ての選択したオブジェクトとその子要素を反復することができます。

for o in Gui.Selection.getSelectionEx():
print o.ObjectName
for s in o.SubElementNames:
print "name: ",s
for s in o.SubObjects:
print "object: ",s

エッジを選択し、このスクリプトでその長さを計算します:

length = 0.0
for o in Gui.Selection.getSelectionEx():
for s in o.SubObjects:
length += s.Length
print "Length of the selected edges:" ,length

OCCボトル

OpenCasCadeをはじめようにはボトルの作成方法についての典型的な例があります。 これはFreeCADの教材としても最適です。実際に以下のページの例とOCCのページの内容とを同時に追うことによって、OCCの構造がどのようにFreeCADの中に実装されているか理解できるでしょう。 以下のスクリプトはFreeCADのインストールにも含まれています（Mod/Partフォルダ内）。pythonインタプリタから次のようにタイプすることで呼び出すことができます:

import Part
import MakeBottle
bottle = MakeBottle.makeBottle()
Part.show(bottle)

完全なスクリプト

MakeBottleスクリプト一式です：

import Part, FreeCAD, math
from FreeCAD import Base

def makeBottle(myWidth=50.0, myHeight=70.0, myThickness=30.0):
   aPnt1=Base.Vector(-myWidth/2.,0,0)
   aPnt2=Base.Vector(-myWidth/2.,-myThickness/4.,0)
   aPnt3=Base.Vector(0,-myThickness/2.,0)
   aPnt4=Base.Vector(myWidth/2.,-myThickness/4.,0)
   aPnt5=Base.Vector(myWidth/2.,0,0)
   
   aArcOfCircle = Part.Arc(aPnt2,aPnt3,aPnt4)
   aSegment1=Part.Line(aPnt1,aPnt2)
   aSegment2=Part.Line(aPnt4,aPnt5)
   aEdge1=aSegment1.toShape()
   aEdge2=aArcOfCircle.toShape()
   aEdge3=aSegment2.toShape()
   aWire=Part.Wire([aEdge1,aEdge2,aEdge3])
   
   aTrsf=Base.Matrix()
   aTrsf.rotateZ(math.pi) # z軸周りを回転
   
   aMirroredWire=aWire.transformGeometry(aTrsf)
   myWireProfile=Part.Wire([aWire,aMirroredWire])
   myFaceProfile=Part.Face(myWireProfile)
   aPrismVec=Base.Vector(0,0,myHeight)
   myBody=myFaceProfile.extrude(aPrismVec)
   myBody=myBody.makeFillet(myThickness/12.0,myBody.Edges)
   neckLocation=Base.Vector(0,0,myHeight)
   neckNormal=Base.Vector(0,0,1)
   myNeckRadius = myThickness / 4.
   myNeckHeight = myHeight / 10
   myNeck = Part.makeCylinder(myNeckRadius,myNeckHeight,neckLocation,neckNormal)
   myBody = myBody.fuse(myNeck)
   
   faceToRemove = 0
   zMax = -1.0
   
   for xp in myBody.Faces:
       try:
           surf = xp.Surface
           if type(surf) == Part.Plane:
               z = surf.Position.z
               if z > zMax:
                   zMax = z
                   faceToRemove = xp
       except:
           continue
   
   myBody = myBody.makeThickness([faceToRemove],-myThickness/50 , 1.e-3)
   
   return myBody

詳細な説明

import Part, FreeCAD, math
from FreeCAD import Base

PartモジュールはもちろんですがFreeCAD.Baseモジュールも必要です。このモジュールにはベクトルや行列といったFreeCADの基本構造が含まれています。

def makeBottle(myWidth=50.0, myHeight=70.0, myThickness=30.0):
   aPnt1=Base.Vector(-myWidth/2.,0,0)
   aPnt2=Base.Vector(-myWidth/2.,-myThickness/4.,0)
   aPnt3=Base.Vector(0,-myThickness/2.,0)
   aPnt4=Base.Vector(myWidth/2.,-myThickness/4.,0)
   aPnt5=Base.Vector(myWidth/2.,0,0)

ここではmakeBottle関数を定義します。この関数は、上記の例のように、引数無しでも呼ぶことができます。その場合には、幅、高さ、厚さの初期値が使用されます。次に基本的なプロファイルの構築に使用する点を定義します。

   aArcOfCircle = Part.Arc(aPnt2,aPnt3,aPnt4)
   aSegment1=Part.Line(aPnt1,aPnt2)
   aSegment2=Part.Line(aPnt4,aPnt5)

ここでは実際のジオメトリを定義しています。円弧を一つ、点を三つ、そして二点で構成される線分を二つ作ります。

   aEdge1=aSegment1.toShape()
   aEdge2=aArcOfCircle.toShape()
   aEdge3=aSegment2.toShape()
   aWire=Part.Wire([aEdge1,aEdge2,aEdge3])

ジオメトリとシェイプの違いを覚えているでしょうか？ここでは、作成したジオメトリを使ってシェイプを作り上げています。3つのエッジ（直線や曲線です）を作り、それらを使いワイヤーを一つ作成します。

   aTrsf=Base.Matrix()
   aTrsf.rotateZ(math.pi) # rotate around the z-axis
   aMirroredWire=aWire.transformGeometry(aTrsf)
   myWireProfile=Part.Wire([aWire,aMirroredWire])

ここまでで、まだプロファイルは半分しか出来上がっていません。同じ方法でプロファイル全体を作成するよりも、これまで作成したものをミラーして、2つの半分を一つにくっつけるほうが簡単です。それにはまず行列を作成します。行列は3次元空間のオブジェクトを変換するとても一般的な方法です。 行列を使えば、3Dオブジェクトの厄介な基本的な変換（移動、回転、スケール）が一つで済むのです。ここでは行列を作成し、それを反転します。作成したワイヤーにこの変換行列を適用してコピーを作ります。ここまで、2本のワイヤーができました。ワイヤーは、実際にはエッジのリストですので、これらのワイヤーから3つ目のワイヤーを作ることができます。

   myFaceProfile=Part.Face(myWireProfile)
   aPrismVec=Base.Vector(0,0,myHeight)
   myBody=myFaceProfile.extrude(aPrismVec)
   myBody=myBody.makeFillet(myThickness/12.0,myBody.Edges)

すでに閉じたワイヤーがあるので、これをフェイスに変換することができます。フェイスを作ってしまえば、それを押し出すことができるようになります。このようにしてソリッドができました。では、次にこのオブジェクトに素敵なフィレットを少し使ってみましょう。デザインには気を使うでしょ？

   neckLocation=Base.Vector(0,0,myHeight)
   neckNormal=Base.Vector(0,0,1)
   myNeckRadius = myThickness / 4.
   myNeckHeight = myHeight / 10
   myNeck = Part.makeCylinder(myNeckRadius,myNeckHeight,neckLocation,neckNormal)

これでボトルの本体はできました。あとはボトルの首を作成する必要があります。そこで、円柱で新しいソリッドを作成します。

   myBody = myBody.fuse(myNeck)

他のアプリではユニオンとも呼ばれることもあるフューズ操作はとても強力な機能です。この操作は結合処理において結合すべきものと削除すべきものを管理します。

   return myBody

次にこの関数の結果としてPartソリッドを返します。このPartソリッドは、他のPartシェイプと同様に以下の方法でFreeCADドキュメント内のオブジェクトの属性になります。

myObject = FreeCAD.ActiveDocument.addObject("Part::Feature","myObject")
myObject.Shape = bottle

あるいはもっとシンプルな方法もあります:

Part.show(bottle)

読み込みと保存

Partモジュールの作業内容を保存する方法はいくつかあります。もちろんFreeCADドキュメントを保存することもできますが、PartオブジェクトをBREPやIGS、STEPやSTLなどの共通CADフォーマットに直接保存することもできます。

シェイプをファイルへ保存するのは簡単です。全てのシェイプオブジェクトで、exportBre()、pexportIges()、exportStl()、およびexportStep()メソッドが利用できます。ではやってみましょう：

import Part
s = Part.makeBox(0,0,0,10,10,10)
s.exportStep("test.stp")

ここではSTEPファイルへボックスを保存します。BREPやIGESやSTEPファイルを読み込むには、単純に反対の操作を行います：

import Part
s = Part.Shape()
s.read（"test.stp"）

BREPやIGES、STEPファイルのインポートは、メニューの「File -> Open」か「File -> Import」からも直接行えます。エクスポートは「File -> Export」で行えます。

Partオブジェクトをメッシュに変換する

Part形状のような上位レベルのオブジェクトを メッシュのような単純なオブジェクトに変換するのは比較的簡単な処理です。Partオブジェクトの全ての面を三角形に変換して、結果の三角形（モザイク）をメッシュ構築に使用すればいいのです：

# ドキュメントには一つだけPartオブジェクトが入っているとしましょう
import Mesh
faces = []
shape = FreeCAD.ActiveDocument.ActiveObject.Shape
triangles = shape.tessellate(1) # この数値がモザイクの精度を表します
for tri in triangles[1]:
    face = []
    for i in range(3):
        vindex = tri[i]
        face.append(triangles[0][vindex])
    faces.append(face)
m = Mesh.Mesh(faces)
Mesh.show(m)

ときたまOpenCascadeが出力する特定の面の三角形が非常にいびつな場合があります。もし面に長方形パラメータ空間があり、穴やトリム曲線が無ければ独自にメッシュを作成することもできます：

import Mesh
def makeMeshFromFace(u,v,face):
(a,b,c,d)=face.ParameterRange
pts=[]
for j in range(v):
for i in range(u):
s=1.0/(u-1)*(i*b+(u-1-i)*a)
t=1.0/(v-1)*(j*d+(v-1-j)*c)
pts.append(face.valueAt(s,t))

mesh=Mesh.Mesh()
for j in range(v-1):
for i in range(u-1):
mesh.addFacet(pts[u*j+i],pts[u*j+i+1],pts[u*(j+1)+i])
mesh.addFacet(pts[u*(j+1)+i],pts[u*j+i+1],pts[u*(j+1)+i+1])

return mesh

メッシュをPartオブジェクトに変換する

メッシュからPartオブジェクトへの変換はCADでの作業でも非常に重要な操作です。他の人たちからメッシュ形式の3Dデータを受け取ったり、他のアプリケーションからメッシュ形式の3Dデータを出力するというのはよくあることだからです。自由形状や大きな描画シーンを表現する場合にはメッシュは非常に実用的です。とても軽量だからです。しかしCADでの用途を考えた場合、一般的には三角形ではなく曲線で作成された面やソリッドなど、もっと多くの情報を保持できるより上位のオブジェクトの方が好まれます。

メッシュからこういった（FreeCADのパートモジュールで扱われる様な ）上位オブジェクトへの変換は簡単な処理ではありません。メッシュは数千もの三角形で構成されている場合もありますし（例えば3Dスキャナーによって生成されている場合）、面と同じだけの数のソリッドを持った場合には処理がとんでもなく重くなることも考えられます。従って多くの場合、変換時に最適化を施す必要があるのです。

FreeCADでは現在、メッシュをPartオブジェクトに変換する二つのメソッドが用意されています。一つ目は単純なもので何の最適化も施さずに直接変換を行います：

import Mesh,Part
mesh = Mesh.createTorus()
shape = Part.Shape()
shape.makeShapeFromMesh(mesh.Topology,0.05) # 二つ目の引数は縫い合わせの許容誤差です
solid = Part.makeSolid(shape)
Part.show(solid)

二つ目のメソッドではメッシュの二つのファセットが作る角度が特定の値を下回る場合にその二つを同一面とみなします。これによってより単純な形状が作成できるのです：

# ドキュメントには一つだけMeshオブジェクトが入っているとしましょう
import Mesh,Part,MeshPart
faces = []
mesh = App.ActiveDocument.ActiveObject.Mesh
segments = mesh.getPlanes(0.00001) # ここではより厳しい許容誤差を使用します

for i in segments:
  if len(i) > 0:
     # 線分は内部に穴を持つことができます
     wires = MeshPart.wireFromSegment(mesh, i)
     # 外部境界が最大のバウンディングボックスを持つものであると仮定します
     if len(wires) > 0:
        ext=None
        max_length=0
        for i in wires:
           if i.BoundBox.DiagonalLength > max_length:
              max_length = i.BoundBox.DiagonalLength
              ext = i

        wires.remove(ext)
        # 内部のワイヤーが全てマークされ、向きが反転されなければなりません。さもなければPart.Faceが失敗します
        for i in wires:
           i.reverse()

        # 外部のワイヤーがリストの先頭になっていることを確認してください
        wires.insert(0, ext)
        faces.append(Part.Face(wires))

shell=Part.Compound(faces)
Part.show(shell)
#solid = Part.Solid(Part.Shell(faces))
#Part.show(solid)

FreeCADは基本的には様々なライブラリのコラージュです。なかでも最も重要なものはジオメトリーの管理と構築のためのOpenCascade、ジオメトリーを表示するためのCoin3d、そしてそれら全てを優れたグラフィカルユーザーインターフェースにまとめあげるQtです。

FreeCADの3Dビューに表示されるジオメトリーはCoin3Dライブラリによってレンダリングされています。Coin3DはOpenInventor規格の実装の一つです。OpenCascade自体にも同じ機能がありますがFreeCAD開発が始まった最初の段階でOpenCascadeに組み込まれたビューアーを使わず、より高性能なCoin3Dを使う、という決断がされました。このライブラリについて学ぶ早道はOpen Inventor Mentorを読むことです。

OpenInventorは実質的には3Dシーン記述言語です。OpenInventorで記述されたシーンはOpenGLによって画面にレンダリングされます。Coin3Dはこの部分の処理を行います。つまりプログラマーは複雑なOpenGLの呼び出しを扱うこと無く、正しいOpenInventorコードを入力するだけでいいのです。OpenInventorの大きな利点はとても広く知られ、またよくドキュメント化された規格であるということです。

FreeCADが行う大きな仕事の一つはOpenCascadeのジオメトリー情報をOpenInventor言語に翻訳することです。

OpenInventorでは3Dシーンを下記に示すようなシーングラフ形式で記述します：

Inventor mentorからの画像

OpenInventorのシーングラフではジオメトリー、色、マテリアル、ライトなど3Dシーンに含まれるものが全て記述され、それらすべてのデータが扱いやすい明快な構造体に整理されます。全てのものをサブ構造体にグループ化することや、シーンの内容をかなり自由な形式で整理することも可能です。以下はOpenInventorファイルのサンプルです：

#Inventor V2.0 ascii

Separator { 
    RotationXYZ {
       axis Z
       angle 0
    }
    Transform {
       translation 0 0 0.5
    }
    Separator {
       Material {
          diffuseColor 0.05 0.05 0.05
       }
       Transform {
          rotation 1 0 0 1.5708
          scaleFactor 0.2 0.5 0.2
       }
       Cylinder {
       }
    }
}

見て分かる通り、構造体は非常にシンプルです。データをブロックにまとめるときにはセパレータを使います。ちょうどファイルをフォルダにまとめるのと似ています。各命令文は以降の命令文に影響を与えます。例えばサンプルのルートセパレータにある二つのアイテムは回転と移動ですが、この両方が次のアイテムであるセパレータに影響を与えます。そのセパレータ内ではマテリアルと別の変換が定義されています。従って円筒（Cylinder）は両方の命令文の影響を受けます。一つは直接適用され、もう一つは親セパレータに対して適用されます。

他にもグループ、スイッチ、注釈などシーンを作成するための多くの要素タイプが存在します。色、テクスチャ、シェーディングモード、透過度を使って非常に複雑なマテリアルをオブジェクトに定義することが可能です。またライト、カメラ、あるいは動きさえ定義することができます。さらに複雑な振る舞いを定義するためにOpenInventorファイル内に短いスクリプトを埋め込むことさえ可能なのです。

もしOpenInventorをもっと学びたいと思ったら最も有名なリファレンスであるInventor mentorを見てください。

FreeCADでは通常はOpenInventorのシーングラフを直接操作する必要はありません。メッシュやパート形状などFreeCADドキュメント内のオブジェクトは全て自動的にOpenInventorコードに変換され、3Dビューに表示されるメインシーングラフに挿入されます。またあなたが変更を行ったり、ドキュメントにオブジェクトが追加/削除された際などシーングラフは途切れることなく更新され続けます。実際の所、全ての（App空間内の）オブジェクトにはOpenInventorコード発行用の（Gui空間のオブジェクトに対応する）ビュープロバイダが備わっているのです。

しかしシーングラフに直接アクセスできると非常に便利です。例えば一時的にオブジェクトの表示を変えたり、構築ジオメトリー、補助線、グラフィカルなヒント、あるいはマニピュレーターといったツールや画面上情報など実際にはFreeCADドキュメント内に存在しないオブジェクトをシーンに追加することができます。

FreeCAD自体にもOpenInventorコードを確認したり変更するためのツールがいくつか備わっています。例えば以下のPythonコードを実行すると選択されているオブジェクトのOpenInventorでの表現を表示することができます。

obj = FreeCAD.ActiveDocument.ActiveObject
viewprovider = obj.ViewObject
print viewprovider.toString()

またFreeCADのシーングラフなどCoin3Dによって管理されている全てのものに完全にアクセスするためのPythonモジュールもあります。詳しくはPivyを読んでください。

PivyはFreeCADで使われている3DレンダリングライブラリであるCoin3d用のPythonのバインディングライブラリです。実行中のPythonインタプリタにインポートするとFreeCADの3DビューアーなどのCoin3dシーングラフと直に対話処理を行ったり、新しい3Dビューアーを作成することさえできます。Pivyは標準のFreeCADインストールに同梱されています。

Coinライブラリはいくつかに分割されています。Coin自体はシーングラフの操作を担い、Windowsといった複数のGUIシステム用のパッケージがありますが私たちの場合はQt用になります。これらの分割されたモジュールもシステム上に存在する場合にはPivyから利用することができます。Coinモジュールは常駐していて自由に利用することができます。既にFreeCADによって行われているので3D表示をどのインターフェイスに紐付けするのか気にする必要はありません。私たちがやらなければならないのは以下のコマンドを実行することだけです：

from pivy import coin

シーングラフへのアクセスと変更

典型的なCoinシーンがどの様に構成されているかはシーングラフページで見ました。FreeCADの3Dビューに表示されているものは全てCoinシーングラフであり、同じやり方で構成されています。ルートのノードが一つあり、画面上のオブジェクトは全てその子ノードです。

FreeCADでは3Dビューシーングラフのルートノードに簡単にアクセスすることができます：

sg = FreeCADGui.ActiveDocument.ActiveView.getSceneGraph()
print sg

こうするとルートノードが返されます。

<pivy.coin.SoSelection; proxy of <Swig Object of type 'SoSelection *' at 0x360cb60> > 

シーンの直下の子ノードを調べることもできます。

for node in sg.getChildren():
    print node

SoSeparatorsやSoGroupsといったこれらノードは自身の子ノードを持ちます。利用可能なCoinオブジェクトの全リストはCoin公式ドキュメントにあります。

今度はシーングラフに何か追加してみましょう。すてきな赤い立方体を追加してみることにしましょう：

col = coin.SoBaseColor()
col.rgb=(1,0,0)
cub = coin.SoCube()
myCustomNode = coin.SoSeparator()
myCustomNode.addChild(col)
myCustomNode.addChild(cub)
sg.addChild(myCustomNode)

（すてきな）赤い立方体ができました。以下を試してみてください：

col.rgb=(1,1,0)

わかったでしょうか？実行中であっても全てのものに対してアクセスと変更を行うことができるのです。再計算や再描画は必要ありません。Coinが全て面倒を見てくれます。物体のシーングラフへの追加、プロパティの変更、物体の非表示、一時的なオブジェクトの表示、何でもできます。もちろん3Dビューに関係したことだけですが。この表示はFreeCADがファイルを開いた時とオブジェクトが必要とした時に再計算されます。従って既存のFreeCADオブジェクトの外見を変更した場合、その変更はオブジェクトが再計算されるかファイルを再度開いた瞬間に失われます。

スクリプトでシーングラフを操作する場合の鍵となるのは必要な際に追加したノードの特定のプロパティにアクセスできるということなのです。例えば立方体を動かしたいとしましょう。自作のノードにSoTranslationノードを追加することになるでしょう。ちょうどこんな具合です：

col = coin.SoBaseColor()
col.rgb=(1,0,0)
trans = coin.SoTranslation()
trans.translation.setValue([0,0,0])
cub = coin.SoCube()
myCustomNode = coin.SoSeparator()
myCustomNode.addChild(col)
mtCustomNode.addChild(trans)
myCustomNode.addChild(cub)
sg.addChild(myCustomNode)

OpenInventorのシーングラフではその順番が重要であるということを思い出してください。ノードは以降のノードに影響を与えます。color red、cube、color yellow、sphere とすれば赤い立方体と黄色い球が表示されます。もし今、既存の自作ノードに移動を追加すると移動は立方体の後になり、立方体に影響を与えません。上記のように作成時に挿入しておけば次のようにできます：

trans.translation.setValue([2,0,0])

こうすると立方体が2単位分、右に移動します。 最後に何かを取り除くには次のようにします：

sg.removeChild(myCustomNode)

コールバック機能の使用

コールバック機能とはCoinライブラリの様な現在使用しているライブラリがコールバック、つまり現在実行中のPythonオブジェクトから特定の関数を呼び出すことを可能にするシステムのことです。これは非常に便利です。これを使うとシーンで何か特定のイベントが起きた場合にCoinからあなたへ通知することができるのです。Coinでは色々なものを監視することができます。マウスの位置、マウスボタンのクリック、キーボードのキーが押されたかどうか、まだまだ他にもあります。

FreeCADではそういったコールバックを簡単に使うための機能があります：

class ButtonTest:
  def __init__(self):
    self.view = FreeCADGui.ActiveDocument.ActiveView
    self.callback = self.view.addEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.getMouseClick) 
  def getMouseClick(self,event_cb):
    event = event_cb.getEvent()
    if event.getState() == SoMouseButtonEvent.DOWN:
      print "Alert!!! A mouse button has been improperly clicked!!!"
      self.view.removeEventCallbackSWIG(SoMouseButtonEvent.getClassTypeId(),self.callback) 

ButtonTest()

コールバックが起きた時にもオブジェクトは実行され続けなければならないのでコールバックはオブジェクトで初期化されなけれればなりません。 利用可能なイベントとパラメータの全リストまたはCoin公式ドキュメントを参照してください。

ドキュメント

残念ながらPivy自体にはちゃんとしたドキュメントがまだありません。しかしPivyはCoinと正確に対応するのでC++スタイルをPythonスタイルに読み替えれば（例えばSoFile::getClassTypeId()はPivyではSoFile.getClassId()となるでしょう）Coinドキュメントをリファレンスとして安全に使用できます。

PyQtはPythonでQtアプリケーションの作成、アクセス、変更を行うためのPythonモジュールです。これを使用すると例えば独自にQtプログラムを作成したり、FreeCADなど実行中のQtアプリケーションのインターフェイスへのアクセスや変更が可能になります。

FreeCAD内部からPyQtモジュールを使用することでFreeCADのインターフェイスを完全に制御することができます。例えば以下のことを行うことができます。

• 独自のパネル、ウィジット、ツールバーの追加
• 既存のパネルへの要素の追加や非表示
• 全ての要素の間のコネクションに対する変更、リダイレクト、追加

PyQtには豊富なAPIドキュメントがあり、またネット上にはどの様にそれが動作するのか教えてくれるチュートリアルがたくさんあります。

もしFreeCADインターフェイスをいじりたいのであれば一番最初にやるべきことはFreeCADのメインウィンドウの参照を作成することです：

import sys
from PyQt4 import QtGui
app = QtGui.qApp
mw = app.activeWindow()

すると例えばインターフェイスの全てのウィジットをブラウジングすることなどができるようになります：

for child in mw.children():
   print 'widget name = ', child.objectName(), ', widget type = ', child

Qtインターフェイスのウィジットは普通、"コンテナ"ウィジット内に入れ子状態になっています。つまりメインウィンドウの子ウィンドウ自体も他の子ウィンドウを収納できるのです。ウィジットのタイプによって行えることは様々です。何ができるのかについてはAPIドキュメントをチェックしてください。

新しいウィジットの追加には例えばdockWidget（FreeCADのサイドパネルの一つに配置できます）が便利です：

myWidget = QtGui.QDockWidget()
mw.addDockWidget(QtCore.Qt.RightDockWidgetArea,myWidget)

さらにいろいろなものをウィジットに直接追加できます：

myWidget.setObjectName("my Nice New Widget")
myWidget.resize(QtCore.QSize(300,100)) # ウィジットのサイズ設定
label = QtGui.QLabel("Hello World", myWidget) # ラベルを作成
label.setGeometry(QtCore.QRect(50,50,200,24)) # そのサイズを設定
label.setObjectName("myLabel") # 名前を設定することで名前を使って検索できるようにします

しかしよく好まれる方法は一度にウィジットの設定を全て行えるUIオブジェクトの作成です。この方法の大きな利点はQt Designerを使うことでこういったUIオブジェクトをグラフィカルな方法で作成できるということです。Qt Designerによって生成された標準的なオブジェクトは以下のようになります：

class myWidget_Ui(object):
  def setupUi(self, myWidget):
    myWidget.setObjectName("my Nice New Widget")
    myWidget.resize(QtCore.QSize(300,100).expandedTo(myWidget.minimumSizeHint())) # ウィジットのサイズを設定

    self.label = QtGui.QLabel(myWidget) # ラベルを作成
    self.label.setGeometry(QtCore.QRect(50,50,200,24)) # そのサイズを設定
    self.label.setObjectName("label") # 名前を設定することで名前を使って検索できるようにします

  def retranslateUi(self, draftToolbar): # ウィジットの翻訳を管理する組み込みのQt関数
    myWidget.setWindowTitle(QtGui.QApplication.translate("myWidget", "My Widget", None, QtGui.QApplication.UnicodeUTF8))
    self.label.setText(QtGui.QApplication.translate("myWidget", "Welcome to my new widget!", None, QtGui.QApplication.UnicodeUTF8))

使用するには以下のようにして新しく作成したウィジットに適用するだけで構いません：

myNewFreeCADWidget = QtGui.QDockWidget() # 新しいウィジットを作成
myNewFreeCADWidget.ui = myWidget_Ui() # UIスクリプトをロード
myNewFreeCADWidget.ui.setupUi(myNewFreeCADWidget) # UIを設定
FCmw.addDockWidget(QtCore.Qt.RightDockWidgetArea,myNewFreeCADWidget) # メインウィンドウにウィジットを追加

FreeCADでは、標準オブジェクト型のだけではなくメッシュや部品のオブジェクトもすべてpythonスクリプトのオブジェクトとして構成できます。これらはPythonの特徴といえます。これらのオブジェクトは、他のFreeCADのオブジェクトとまったく同じように動作し自動的にファイルへ保存や読み込みが行われます。 知っておくべきひとつの特徴として、オブジェクトはpythonのcPickleモジュールと一緒にFreeCADのFcStdファイルに保存されます。そのモジュールは文字列で表されたpythonオブジェクト保存されたファイルに追記できるように変更します。cPickleモジュールは、読み込まれると元のオブジェクトを再作成するために、その文字列を使用してオブジェクトを作成したソースコードへのアクセスを提供しています。このようなカスタムオブジェクトを保存して、オブジェクトを生成したPythonコードが存在していない他のマシン上でそれを開いた場合、オブジェクトが再作成されないということです。そのため、他の人にこのようなオブジェクトを配布する場合は、一緒に作成したPythonスクリプトを配布する必要があります。 Pythonの特長は、すべてのFreeCADの機能に当てはまります。これらはアプリケーションとGUIの部分に分類されます。アプリケーション部、ドキュメントオブジェクト、オブジェクトのジオメトリ定義、そのGUI部分、ViewProviderObject、どのように画面描画を行うか定義したオブジェクトです。プロパティはFreeCADで事前に定義されたプロパティの種類のいずれかでなければなりません。そしてプロパティを表示するウィンドウが生成され、ユーザーがそれらを変更することができます。この場合、FeaturePythonオブジェクトは完全なパラメータです。別のオブジェクトとそのViewObjectのプロパティを定義することができます。

基本的な例

このサイトsrc/Mod/TemplatePyMod/FeaturePython.pyでサンプルのファイルといくつかの他のサンプルを一緒に見ることができます。

"Examples for a feature class and its view provider."

import FreeCAD, FreeCADGui
from pivy import coin

class Box:
def __init__(self, obj):
"Add some custom properties to our box feature"
obj.addProperty("App::PropertyLength","Length","Box","Length of the box").Length=1.0
obj.addProperty("App::PropertyLength","Width","Box","Width of the box").Width=1.0
obj.addProperty("App::PropertyLength","Height","Box", "Height of the box").Height=1.0
obj.Proxy = self

def onChanged(self, fp, prop):
"Do something when a property has changed"
FreeCAD.Console.PrintMessage("Change property: " + str(prop) + "\n")
 
def execute(self, fp):
"Do something when doing a recomputation, this method is mandatory"
FreeCAD.Console.PrintMessage("Recompute Python Box feature\n")
 
class ViewProviderBox:
def __init__(self, obj):
"Set this object to the proxy object of the actual view provider"
obj.addProperty("App::PropertyColor","Color","Box","Color of the box").Color=(1.0,0.0,0.0)
obj.Proxy = self
 
def attach(self, obj):
"Setup the scene sub-graph of the view provider, this method is mandatory"
self.shaded = coin.SoGroup()
self.wireframe = coin.SoGroup()
self.scale = coin.SoScale()
self.color = coin.SoBaseColor()
 
data=coin.SoCube()
self.shaded.addChild(self.scale)
self.shaded.addChild(self.color)
self.shaded.addChild(data)
obj.addDisplayMode(self.shaded,"Shaded");
style=coin.SoDrawStyle()
style.style = coin.SoDrawStyle.LINES
self.wireframe.addChild(style)
self.wireframe.addChild(self.scale)
self.wireframe.addChild(self.color)
self.wireframe.addChild(data)
obj.addDisplayMode(self.wireframe,"Wireframe");
self.onChanged(obj,"Color")
 
def updateData(self, fp, prop):
"If a property of the handled feature has changed we have the chance to handle this here"
# fp is the handled feature, prop is the name of the property that has changed
l = fp.getPropertyByName("Length")
w = fp.getPropertyByName("Width")
h = fp.getPropertyByName("Height")
self.scale.scaleFactor.setValue(l,w,h)
pass
 
def getDisplayModes(self,obj):
"Return a list of display modes."
modes=[]
modes.append("Shaded")
modes.append("Wireframe")
return modes
 
def getDefaultDisplayMode(self):
"Return the name of the default display mode. It must be defined in getDisplayModes."
return "Shaded"
 
def setDisplayMode(self,mode):
"Map the display mode defined in attach with those defined in getDisplayModes.\
                Since they have the same names nothing needs to be done. This method is optional"
return mode
 
def onChanged(self, vp, prop):
"Here we can do something when a single property got changed"
FreeCAD.Console.PrintMessage("Change property: " + str(prop) + "\n")
if prop == "Color":
c = vp.getPropertyByName("Color")
self.color.rgb.setValue(c[0],c[1],c[2])
 
def getIcon(self):
"Return the icon in XPM format which will appear in the tree view. This method is\
                optional and if not defined a default icon is shown."
return """
/* XPM */
static const char * ViewProviderBox_xpm[] = {
"16 16 6 1",
" c None",
".c #141010",
"+c #615BD2",
"@c #C39D55",
"#c #000000",
"$c #57C355",
"        ........",
"   ......++..+..",
"   .@@@@.++..++.",
"   .@@@@.++..++.",
"   .@@  .++++++.",
"  ..@@  .++..++.",
"###@@@@ .++..++.",
"##$.@@$#.++++++.",
"#$#$.$$$........",
"#$$#######      ",
"#$$#$$$$$#      ",
"#$$#$$$$$#      ",
"#$$#$$$$$#      ",
" #$#$$$$$#      ",
"  ##$$$$$#      ",
"   #######      "};
"""
 
def __getstate__(self):
"When saving the document this object gets stored using Python's cPickle module.\
                Since we have some un-pickable here -- the Coin stuff -- we must define this method\
                to return a tuple of all pickable objects or None."
return None
 
def __setstate__(self,state):
"When restoring the pickled object from document we have the chance to set some internals here.\
                Since no data were pickled nothing needs to be done here."
return None
 
 
def makeBox():
FreeCAD.newDocument()
a=FreeCAD.ActiveDocument.addObject("App::FeaturePython","Box")
Box(a)
 ViewProviderBox(a.ViewObject)

利用可能なプロパティ

プロパティはFeaturePythonオブジェクトの基礎です。それらを介して、ユーザーが自分のオブジェクトをやり取りしたり変更することができます。ドキュメントで新しいFeaturePythonオブジェクト作成後に（a=FreeCAD.ActiveDocument.addObject("App::FeaturePython","Box"))利用可能なプロパティの一覧を取得できます：

a.supportedProperties()

使用可能なプロパティを取得します:

App::PropertyBool
App::PropertyFloat
App::PropertyFloatList
App::PropertyFloatConstraint
App::PropertyAngle
App::PropertyDistance
App::PropertyInteger
App::PropertyIntegerConstraint
App::PropertyPercent
App::PropertyEnumeration
App::PropertyIntegerList
App::PropertyString
App::PropertyStringList
App::PropertyLink
App::PropertyLinkList
App::PropertyMatrix
App::PropertyVector
App::PropertyVectorList
App::PropertyPlacement
App::PropertyPlacementLink
App::PropertyColor
App::PropertyColorList
App::PropertyMaterial
App::PropertyPath
App::PropertyFile
App::PropertyFileIncluded
Part::PropertyPartShape
Part::PropertyFilletContour
Part::PropertyCircle

カスタムオブジェクトにプロパティを追加するときは、次の点に注意してください：

• プロパティの説明の中で"<"または ">"の文字を使用しないでください（.fcstdファイル内のXMLの部分を壊してしまいます）
• プロパティは、.fcstdファイルにアルファベット順に格納されています。プロパティの中で形状を定義している場合、名前がアルファベット順で"Shape"の後に来るすべてのプロパティは、形状がロードされた後に読み込まれるため、おかしい動作を引き起こす可能性があります

より複雑な例

この例ではPart Moduleで八面体やpivyとコインを作成するために使用します。 最初はドキュメントオブジェクトそのものです。

import FreeCAD, FreeCADGui, Part

   class Octahedron:
      def __init__(self, obj):
         "Add some custom properties to our box feature"
         obj.addProperty("App::PropertyLength","Length","Octahedron","Length of the octahedron").Length=1.0
         obj.addProperty("App::PropertyLength","Width","Octahedron","Width of the octahedron").Width=1.0
         obj.addProperty("App::PropertyLength","Height","Octahedron", "Height of the octahedron").Height=1.0
         obj.addProperty("Part::PropertyPartShape","Shape","Octahedron", "Shape of the octahedron")
         obj.Proxy = self

      def execute(self, fp):
         # Define six vetices for the shape
         v1 = FreeCAD.Vector(0,0,0)
         v2 = FreeCAD.Vector(fp.Length,0,0)
         v3 = FreeCAD.Vector(0,fp.Width,0)
         v4 = FreeCAD.Vector(fp.Length,fp.Width,0)
         v5 = FreeCAD.Vector(fp.Length/2,fp.Width/2,fp.Height/2)
         v6 = FreeCAD.Vector(fp.Length/2,fp.Width/2,-fp.Height/2)
         
         # Make the wires/faces
         f1 = self.make_face(v1,v2,v5)
         f2 = self.make_face(v2,v4,v5)
         f3 = self.make_face(v4,v3,v5)
         f4 = self.make_face(v3,v1,v5)
         f5 = self.make_face(v2,v1,v6)
         f6 = self.make_face(v4,v2,v6)
         f7 = self.make_face(v3,v4,v6)
         f8 = self.make_face(v1,v3,v6)
         shell=Part.makeShell([f1,f2,f3,f4,f5,f6,f7,f8])
         solid=Part.makeSolid(shell)
         fp.Shape = solid

      # helper mehod to create the faces
      def make_face(self,v1,v2,v3):
         wire = Part.makePolygon([v1,v2,v3,v1])
         face = Part.Face(wire)
         return face

ここで我々は、3Dシーン内のオブジェクトを表示するための対応するViewProviderObjectを使用します：

   class ViewProviderOctahedron:
      def __init__(self, obj):
         "Set this object to the proxy object of the actual view provider"
         obj.addProperty("App::PropertyColor","Color","Octahedron","Color of the octahedron").Color=(1.0,0.0,0.0)
         obj.Proxy = self

      def attach(self, obj):
         "Setup the scene sub-graph of the view provider, this method is mandatory"
         self.shaded = coin.SoGroup()
         self.wireframe = coin.SoGroup()
         self.scale = coin.SoScale()
         self.color = coin.SoBaseColor()

         self.data=coin.SoCoordinate3()
         self.face=coin.SoIndexedLineSet()

         self.shaded.addChild(self.scale)
         self.shaded.addChild(self.color)
         self.shaded.addChild(self.data)
         self.shaded.addChild(self.face)
         obj.addDisplayMode(self.shaded,"Shaded");
         style=coin.SoDrawStyle()
         style.style = coin.SoDrawStyle.LINES
         self.wireframe.addChild(style)
         self.wireframe.addChild(self.scale)
         self.wireframe.addChild(self.color)
         self.wireframe.addChild(self.data)
         self.wireframe.addChild(self.face)
         obj.addDisplayMode(self.wireframe,"Wireframe");
         self.onChanged(obj,"Color")

      def updateData(self, fp, prop):
         "If a property of the handled feature has changed we have the chance to handle this here"
         # fp is the handled feature, prop is the name of the property that has changed
         if prop == "Shape":
            s = fp.getPropertyByName("Shape")
            self.data.point.setNum(6)
            cnt=0
            for i in s.Vertexes:
               self.data.point.set1Value(cnt,i.X,i.Y,i.Z)
               cnt=cnt+1
            
            self.face.coordIndex.set1Value(0,0)
            self.face.coordIndex.set1Value(1,1)
            self.face.coordIndex.set1Value(2,2)
            self.face.coordIndex.set1Value(3,-1)

            self.face.coordIndex.set1Value(4,1)
            self.face.coordIndex.set1Value(5,3)
            self.face.coordIndex.set1Value(6,2)
            self.face.coordIndex.set1Value(7,-1)

            self.face.coordIndex.set1Value(8,3)
            self.face.coordIndex.set1Value(9,4)
            self.face.coordIndex.set1Value(10,2)
            self.face.coordIndex.set1Value(11,-1)

            self.face.coordIndex.set1Value(12,4)
            self.face.coordIndex.set1Value(13,0)
            self.face.coordIndex.set1Value(14,2)
            self.face.coordIndex.set1Value(15,-1)

            self.face.coordIndex.set1Value(16,1)
            self.face.coordIndex.set1Value(17,0)
            self.face.coordIndex.set1Value(18,5)
            self.face.coordIndex.set1Value(19,-1)

            self.face.coordIndex.set1Value(20,3)
            self.face.coordIndex.set1Value(21,1)
            self.face.coordIndex.set1Value(22,5)
            self.face.coordIndex.set1Value(23,-1)

            self.face.coordIndex.set1Value(24,4)
            self.face.coordIndex.set1Value(25,3)
            self.face.coordIndex.set1Value(26,5)
            self.face.coordIndex.set1Value(27,-1)

            self.face.coordIndex.set1Value(28,0)
            self.face.coordIndex.set1Value(29,4)
            self.face.coordIndex.set1Value(30,5)
            self.face.coordIndex.set1Value(31,-1)

      def getDisplayModes(self,obj):
         "Return a list of display modes."
         modes=[]
         modes.append("Shaded")
         modes.append("Wireframe")
         return modes

      def getDefaultDisplayMode(self):
         "Return the name of the default display mode. It must be defined in getDisplayModes."
         return "Shaded"

      def setDisplayMode(self,mode):
         return mode

      def onChanged(self, vp, prop):
         "Here we can do something when a single property got changed"
         FreeCAD.Console.PrintMessage("Change property: " + str(prop) + "\n")
         if prop == "Color":
            c = vp.getPropertyByName("Color")
            self.color.rgb.setValue(c[0],c[1],c[2])

      def getIcon(self):
         return """
            /* XPM */
            static const char * ViewProviderBox_xpm[] = {
            "16 16 6 1",
            "    c None",
            ".   c #141010",
            "+   c #615BD2",
            "@   c #C39D55",
            "#   c #000000",
            "$   c #57C355",
            "        ........",
            "   ......++..+..",
            "   .@@@@.++..++.",
            "   .@@@@.++..++.",
            "   .@@  .++++++.",
            "  ..@@  .++..++.",
            "###@@@@ .++..++.",
            "##$.@@$#.++++++.",
            "#$#$.$$$........",
            "#$$#######      ",
            "#$$#$$$$$#      ",
            "#$$#$$$$$#      ",
            "#$$#$$$$$#      ",
            " #$#$$$$$#      ",
            "  ##$$$$$#      ",
            "   #######      "};
            """

      def __getstate__(self):
         return None

      def __setstate__(self,state):
         return None

最後に呼び出す必要があるオブジェクトとViewオブジェクトを定義します。

      FreeCAD.newDocument()
      a=FreeCAD.ActiveDocument.addObject("App::FeaturePython","Octahedron")
      Octahedron(a)
      ViewProviderOctahedron(a.ViewObject)

オブジェクトの選択方法

ビューポートでオブジェクトやそれの少なくとも一部をクリックすることによって選択したい場合は、SoFCSelectionノード内のコインジオメトリを含める必要があります。オブジェクトに複雑な表現やウィジェット、注釈などがある場合は、SoFCSelectionにその一部を含めることができます。SoFCSelectionで常に選択/非選択なのかを検出するために、不要なスキャンで過負荷にしないためにFreeCADによってスキャンされている。例にself.faceを含めるようにどうなるのかです：

selectionNode = coin.SoType.fromName("SoFCSelection").createInstance()
selectionNode.documentName.setValue(FreeCAD.ActiveDocument.Name)
selectionNode.objectName.setValue(obj.Object.Name) # here obj is the ViewObject, we need its associated App Object
selectionNode.subElementName.setValue("Face")
selectNode.addChild(self.face)
...
self.shaded.addChild(selectionNode)
self.wireframe.addChild(selectionNode)

単に、SoFCSelectionノードを作成し、それにジオメトリノードを追加し、その後、直接ジオメトリノードを追加する代わりに、メインノードに追加します。

単純な図形での作業

パラメトリックオブジェクトが単に形状を出力するだけの場合は、ViewProviderObjectを使用する必要はありません。形状はFreeCADの標準的な形状表現を用いて表示されます：

class Line:
    def __init__(self, obj):
        "App two point properties" 
        obj.addProperty("App::PropertyVector","p1","Line","Start point")
        obj.addProperty("App::PropertyVector","p2","Line","End point").p2=FreeCAD.Vector(1,0,0)
        obj.Proxy = self

    def execute(self, fp):
        "Print a short message when doing a recomputation, this method is mandatory" 
        fp.Shape = Part.makeLine(fp.p1,fp.p2)

a=FreeCAD.ActiveDocument.addObject("Part::FeaturePython","Line")
Line(a)
a.ViewObject.Proxy=0 # just set it to something different from None (this assignment is needed to run an internal notification)
FreeCAD.ActiveDocument.recompute()

他のプログラムやスタンドアローンのPythonコンソールにFreeCADをPythonモジュールとしてインポートするための機能は驚くほど充実しています。FreeCADのモジュールとコンポーネントの全てをまとめてインポートできるのです。FreeCADのGUIをPythonモジュールとしてインポートすることさえできます・・多少の制約はありますが。

GUIなしでFreeCADを使用

まずはじめに思いつく直接的で簡単で便利な応用はFreeCADドキュメントをあなたのプログラムにインポートすることです。次の例ではFreeCADドキュメントのPartジオメトリーをblenderにインポートしています。スクリプトはこれで全てです。このシンプルさにあなたが感動してくれるといいのですが：

FREECADPATH = '/opt/FreeCAD/lib' # FreeCAD.soファイルまたはFreeCAD.dllファイルのパス
import Blender, sys
sys.path.append(FREECADPATH)

def import_fcstd(filename):
   try:
       import FreeCAD
   except ValueError:
       Blender.Draw.PupMenu('Error%t|FreeCAD library not found. Please check the FREECADPATH variable in the import script is correct')
   else:
       scene = Blender.Scene.GetCurrent()
       import Part
       doc = FreeCAD.open(filename)
       objects = doc.Objects
       for ob in objects:
           if ob.Type[:4] == 'Part':
               shape = ob.Shape
               if shape.Faces:
                   mesh = Blender.Mesh.New()
                   rawdata = shape.tessellate(1)
                   for v in rawdata[0]:
                       mesh.verts.append((v.x,v.y,v.z))
                   for f in rawdata[1]:
                       mesh.faces.append.append(f)
                   scene.objects.new(mesh,ob.Name)
       Blender.Redraw()

def main():
   Blender.Window.FileSelector(import_fcstd, 'IMPORT FCSTD', 
                       Blender.sys.makename(ext='.fcstd'))    

# This lets you import the script without running it
if __name__=='__main__':
   main()

まず重要なのはPythonがちゃんとFreeCADライブラリを見つけ出しているかの確認です。それが済めば私たちが使っているPartなどFreeCADモジュール全てを自動的に利用できるようになります。そこでまずPythonがモジュールを検索する位置を示すsys.path変数を取り、そこにFreeCADのlibのパスを追加しています。ここで行った変更は一時的なものでPythonインタプリタの終了時に消えます。これとは別にFreeCADライブラリをPythonの検索パスの一つにリンクさせることもできます。今回のスクリプトではパスを定数（FREECADPATH）に入れています。こうしておけば他のユーザーが自分のシステム用にスクリプトを調整するのが簡単になるでしょう。

いったんライブラリのロード（try/except部分）が行われれば、いよいよFreeCADを使って作業を行うことができます。やり方はFreeCAD独自の内部Pythonインタプリタの時と同じです。main()関数を使って渡されたFreeCADドキュメントを開き、そのオブジェクトのリストを作成しています。それから関心のあるPartジオメトリーだけを選び出すために各オブジェクトのTypeプロパティに "Part"が入っているかどうか確認し、それをモザイク構造（tessellate）に変換します。

このモザイク構造から頂点のリストと頂点をインデックスとして定義された面のリストが作成されます。これで完璧です。何しろblenderがメッシュを定義するのと全く同じ方法なのですから。やっていることは馬鹿馬鹿しいほど単純です。ただ両方のリストの内容をblenderのmeshのvertsとfacesに追加するだけです。全て終わったら画面を再描画して終わりです！

もちろんこのスクリプトは非常に簡単なものなので（実を言うともっと応用的なものも作ってあります）、あなたはこれを拡張したくなるでしょう。例えばメッシュオブジェクトのインポート、面の無いPartジオメトリーのインポート、FreeCADで読める他のファイルフォーマットのインポートといったものが考えられます。またジオメトリーをFreeCADドキュメントとしてエクスポートしたいと思うかもしれません。同じようにしてできます。あるいはダイアログを使ってユーザーが何をインポートするか選べるようにしたいと思うかも。他にもあるでしょう。実際の所、これら全てに共通して言える利点はあなたが選んだプログラムの結果出力用にFreeCADに基礎となる作業をさせることができる、ということなのです。

GUIありでFreeCADを使用

バージョン4.2からQtには興味深い機能が追加されました。Qt-GUI依存のプラグインを非Qtなホストアプリケーションに埋め込み、ホスト側のイベントループを共有できるようになったのです。

特にFreeCADについて言えば、これは別のアプリケーション内から全体のユーザーインターフェイスごとFreeCADをインポートでき、ホストアプリケーションがFreeCADを完全に制御できるということを意味します。

これを行うためのPythonコードは全部でたったのニ行です。

import FreeCADGui 
FreeCADGui.showMainWindow()

もしホストアプリケーションがQtベースであればこの方法はQtがサポートされている全てのプラットフォームで動作します。ただしホスト側はFreeCADと同じバージョンのQtとリンクされている必要があります。さもないと予期しない実行時エラーが起きる可能性があります。

非Qtなアプリケーションでも知っておく必要のある制約はごくわずかです。この方法は恐らく他のツールキットと一緒に使っても動作しません。 Windowsの場合、ホストアプリケーションはWin32を直接使用しているかwxWidgets、MFC、WinFormなど内部でWin32APIを使用しているツールキットを使用していなければなりません。X11下で動作するためにはホストアプリケーションは"glib"ライブラリをリンクしている必要があります。

またコンソールアプリケーションではこの方法は使えないことに注意してください。なぜならイベントループ実行が存在しないからです。

このページにはフォーラムでユーザーが作成したり議論した中から集めたFreeCAD用Pythonコードのサンプル、コード片、コードの一部を集めて載せています。あなたのスクリプトの参考にしてください・・・

典型的なInitGui.pyファイル

全てのモジュールにはメインモジュールファイルに加えてメインGUIにモジュールを挿入するためのInitGui.pyファイルが含まれていなければなりません。これはその単純な例です。

class ScriptWorkbench (Workbench): 
    MenuText = "Scripts"
    def Initialize(self):
        import Scripts # Scripts.pyがあなたのモジュールとします
        list = ["Script_Cmd"] # このリストにはScripts.pyで定義されているであろうコマンドの名前が代入されていなければなりません
        self.appendToolbar("My Scripts",list) 
        
Gui.addWorkbench(ScriptWorkbench())

典型的なモジュールファイル

モジュールが行う処理の全てが記載されているメインモジュールファイルの例です。前の例で呼び出されるScripts.pyファイルです。自作のコマンドの全てをここに記載します。

import FreeCAD, FreeCADGui 

class ScriptCmd: 
   def Activated(self): 
       # ここにあなたのScriptCmdが行うことを書きます・・・
       FreeCAD.Console.PrintMessage('Hello, World!')
   def GetResources(self): 
       return {'Pixmap' : 'path_to_an_icon/myicon.png', 'MenuText': 'Short text', 'ToolTip': 'More detailed text'} 
      
FreeCADGui.addCommand('Script_Cmd', ScriptCmd())

新しいファイルタイプをインポート

FreeCADでは簡単に新しいファイルタイプ用のインポート処理を作成することができます。FreeCADはデータを開かれているドキュメントからインポートするか、たんに直接新しいファイルタイプを開くかを区別しません。やらなければならないのは新しいファイル拡張子を FreeCADのリストに追加し、そのファイルを読み込んで欲しいFreeCADオブジェクトを作成するコードを書くことだけです：

リストに新しいファイル拡張子を追加するためには以下の行をInitGui.pyに追加しなければなりません：

# .extファイルを開いて読み込むためのコードがあるファイルをImport_Ext.pyとします
FreeCAD.addImportType("Your new File Type (*.ext)","Import_Ext") 

Import_Ext.pyファイルには以下のように書きます：

def open(filename): 
   doc=App.newDocument()
   # 読み込み、データの識別、対応するFreeCADオブジェクトの作成などfilenameを使って行う必要のある全てをここで行います
   doc.recompute()

新しいファイルタイプへのドキュメントのエクスポートも以下の行を使用する以外は同様にして行います：

FreeCAD.addExportType("Your new File Type (*.ext)","Export_Ext") 

ラインの追加

ラインは2点を持ちます：

import Part,PartGui 
doc=App.activeDocument() 
# ライン要素をドキュメントに追加し、その点を設定
l=Part.Line()
l.StartPoint=(0.0,0.0,0.0)
l.EndPoint=(1.0,1.0,1.0)
doc.addObject("Part::Feature","Line").Shape=l.toShape() 
doc.recompute()

ポリゴンの追加

ポリゴンはつながった線分の集合（AutoCADでいうポリライン）です。線分の集合が閉じている必要はありません。

import Part,PartGui 
doc=App.activeDocument()
n=list() 
# 3Dベクトルを作成し、座標を設定してリストに追加
v=App.Vector(0,0,0) 
n.append(v) 
v=App.Vector(10,0,0) 
n.append(v) 
#・・・全ての節点に対して繰り返します
# ポリゴンオブジェクトを作成し、その節点を設定
p=doc.addObject("Part::Polygon","Polygon") 
p.Nodes=n 
doc.recompute()

グループに対するオブジェクトの追加と削除

doc=App.activeDocument() 
grp=doc.addObject("App::DocumentObjectGroup", "Group") 
lin=doc.addObject("Part::Feature", "Line")
grp.addObject(lin) # linオブジェクトをグループgrpに追加
grp.removeObject(lin) # linオブジェクトをグループgrpから削除

注意：　グループにグループを追加することも可能です・・・

メッシュの追加

import Mesh
doc=App.activeDocument()
# 新しい空のメッシュを作成
m = Mesh.Mesh()
# 12のファセットからボックスを作成
m.addFacet(0.0,0.0,0.0, 0.0,0.0,1.0, 0.0,1.0,1.0)
m.addFacet(0.0,0.0,0.0, 0.0,1.0,1.0, 0.0,1.0,0.0)
m.addFacet(0.0,0.0,0.0, 1.0,0.0,0.0, 1.0,0.0,1.0)
m.addFacet(0.0,0.0,0.0, 1.0,0.0,1.0, 0.0,0.0,1.0)
m.addFacet(0.0,0.0,0.0, 0.0,1.0,0.0, 1.0,1.0,0.0)
m.addFacet(0.0,0.0,0.0, 1.0,1.0,0.0, 1.0,0.0,0.0)
m.addFacet(0.0,1.0,0.0, 0.0,1.0,1.0, 1.0,1.0,1.0)
m.addFacet(0.0,1.0,0.0, 1.0,1.0,1.0, 1.0,1.0,0.0)
m.addFacet(0.0,1.0,1.0, 0.0,0.0,1.0, 1.0,0.0,1.0)
m.addFacet(0.0,1.0,1.0, 1.0,0.0,1.0, 1.0,1.0,1.0)
m.addFacet(1.0,1.0,0.0, 1.0,1.0,1.0, 1.0,0.0,1.0)
m.addFacet(1.0,1.0,0.0, 1.0,0.0,1.0, 1.0,0.0,0.0)
# エッジの長さを100倍にする
m.scale(100.0)
# アクティブなドキュメントにメッシュを追加
me=doc.addObject("Mesh::Feature","Cube")
me.Mesh=m

円弧または円の追加

import Part
doc = App.activeDocument()
c = Part.Circle() 
c.Radius=10.0  
f = doc.addObject("Part::Feature", "Circle") # 円フィーチャーを持つドキュメントを作成
f.Shape = c.toShape() # 円シェイプをシェイププロパティに代入
doc.recompute()

オブジェクト表現へのアクセスと変更

FreeCADドキュメント内の各オブジェクトは関連付けられたビュー表現オブジェクトを持ち、そのビュー表現オブジェクトはそのオブジェクトがどのように表示されるかを定義する色、ライン幅などの全てのプロパティを保持しています。

gad=Gui.activeDocument()   # 対応するAppドキュメント内のフィーチャーと
                          # 対応する全てのビュー表現を保持した
                          # アクティブなドキュメントにアクセス

v=gad.getObject("Cube")    # フィーチャー'Cube' のビュー表現にアクセス
v.ShapeColor               # 色をコンソールに表示
v.ShapeColor=(1.0,1.0,1.0) # シェイプの色を白に設定

Pythonから3Dビューアーのマウスイベントを監視

Inventorフレームワークでは　複数のコールバック用ノードをビューアーへのシーングラフへ追加することができます。デフォルトではFreeCADはビューアーごとに一つのコールバック用ノードがインストールされており、それを使うとグローバルまたはスタティックなC++関数を追加することができます。適切なPythonバインディングではこのテクニックをPythonコードから利用するためのメソッドが提供されています。

App.newDocument()
v=Gui.activeDocument().activeView()

# このクラスは全てのマウスボタンイベントを記録します。登録されたコールバック関数は'down'イベントと'up'イベントで
# 二回、ファイヤーします。これをハンドリングするためのブール値フラグが必要です。
class ViewObserver:
   def logPosition(self, info):
       down = (info["State"] == "DOWN")
       pos = info["Position"]
       if (down):
           FreeCAD.Console.PrintMessage("Clicked on position: ("+str(pos[0])+", "+str(pos[1])+")\n")
      
o = ViewObserver()
c = v.addEventCallback("SoMouseButtonEvent",o.logPosition)

さあ、3Dビューアーの領域のどこかをピックして出力ウィンドウにメッセージが表示されるのを見てください。監視を終了するには次のようにします。

v.removeEventCallback("SoMouseButtonEvent",c)

次のイベント型がサポートされています。

• SoEvent -- 全ての種類のイベント
• SoButtonEvent -- 全てのマウスボタンイベントとキーイベント
• SoLocation2Event -- 2D動作イベント（通常はマウス動作）
• SoMotion3Event -- 3D動作イベント（通常はスペースボール）
• SoKeyboardEvent -- キーダウンイベントとキーアップイベント
• SoMouseButtonEvent -- マウスのボタンダウンイベントとボタンアップイベント
• SoSpaceballButtonEvent -- スペースボールのボタンダウンイベントとボタンアップイベント

addEventCallback()によって登録されるPython関数は辞書を要求します。検知されたイベントに従って辞書には様々なキーが保持されます。

全てのイベントは次のキーを持ちます：

• Type -- イベント型の名前、つまりSoMouseEvent、SoLocation2Event、・・・などです。
• Time -- 文字列形式での現在時刻
• Position -- マウス位置を表す二つの整数のタプル
• ShiftDown -- ブール値。Shiftが押されている場合はtrue、それ以外の場合はfalse。
• CtrlDown -- ブール値。Ctrlが押されている場合はtrue、それ以外の場合はfalse。
• AltDown -- ブール値。Altが押されている場合はtrue、それ以外の場合はfalse。

全てのボタンイベント、つまりキーボードイベント、マウスイベント、スペースボールイベントの場合：

• State -- ボタンが離された場合は'UP'、押された場合は'DOWN'、それ以外の場合は'UNKNOWN'の文字列

キーボードイベントの場合：

• Key -- 押されたキーの文字

マウスボタンイベントの場合：

• Button -- 押されたボタン。BUTTON1、・・・、BUTTON5など。

スペースボールイベントの場合：

• Button -- 押されたボタン。BUTTON1、・・・、BUTTON7など。

そして最後にモーションイベントの場合：

• Translation -- 三つの浮動小数点数のタプル
• Rotation -- 回転のクォータニオン、つまり四つの浮動小数点数のタプル

Pythonでのシーングラフ操作

Coin用のPythonバインディングである'pivy'モジュールを使ってPythonでシーングラフを取得して変更することも可能です。

from pivy.coin import *                # pivyモジュールをロード
view = Gui.ActiveDocument.ActiveView   # アクティブなビューアーを取得
root = view.getSceneGraph()            # ルートはSoSeparatorノード
root.addChild(SoCube())
view.fitAll()

pivyのPythonAPIはSWIGというツールを使って作られています。FreeCADで使用する場合、自作ノードをPythonで直接作成することはできません。 ただし、内部的な名称を使ってノードを作成することはできます。'SoFCSelection'型のインスタンスは次のようにして作成することが可能です：

type = SoType.fromName("SoFCSelection")
node = type.createInstance()

シーングラフに対するオブジェクトの追加と削除

シーングラフへの新しいノードの追加は以下のようにして行うことができます。オブジェクトのジオメトリー、座標、マテリアルの情報の追加のためには常にSoSeparatorの追加が必要なことに注意してください。次の例では (0,0,0)から(10,0,0):に引かれた赤いラインを追加しています。

from pivy import coin
sg = Gui.ActiveDocument.ActiveView.getSceneGraph()
co = coin.SoCoordinate3()
pts = [[0,0,0],[10,0,0]]
co.point.setValues(0,len(pts),pts)
ma = coin.SoBaseColor()
ma.rgb = (1,0,0)
li = coin.SoLineSet()
li.numVertices.setValue(2)
no = coin.SoSeparator()
no.addChild(co)
no.addChild(ma)
no.addChild(li)
sg.addChild(no)

削除は次の様にします：

sg.removeChild(no)

インターフェイスへの自作ウィジットの追加

Qtデザイナーを使って自作のウィジットを作成し、それをPythonスクリプトに変換し、PyQt4を使ってFreeCADインターフェイスへ読み込むことが可能です。

UI Pthonコンパイラ（Qtデザイナーの.uiファイルをPythonコードに変換するツール）を使って作成されたPythonコードは一般的に次の様になります（簡単なものです。直接Pythonで書くこともできます）：

class myWidget_Ui(object):
 def setupUi(self, myWidget):
   myWidget.setObjectName("my Nice New Widget")
   myWidget.resize(QtCore.QSize(QtCore.QRect(0,0,300,100).size()).expandedTo(myWidget.minimumSizeHint())) # ウィジットのサイズを設定

   self.label = QtGui.QLabel(myWidget) # ラベルを作成
   self.label.setGeometry(QtCore.QRect(50,50,200,24)) # サイズを設定
   self.label.setObjectName("label") # 名前を設定。これによって名前での検索が可能になります。

 def retranslateUi(self, draftToolbar): # ウィジットの翻訳を管理する組み込みのQt関数
   myWidget.setWindowTitle(QtGui.QApplication.translate("myWidget", "My Widget", None, QtGui.QApplication.UnicodeUTF8))
   self.label.setText(QtGui.QApplication.translate("myWidget", "Welcome to my new widget!", None, QtGui.QApplication.UnicodeUTF8))

次に必要なことはFreeCADのQtウィンドウへの参照を作成し、そこに自作のウィジットを挿入して、このウィジットを作成したUIコードで"作り変える"ことだけです：

 app = QtGui.qApp
 FCmw = app.activeWindow() # アクティブなQtウィンドウ。その内部にいるのでFreeCADウィンドウです。
 myNewFreeCADWidget = QtGui.QDockWidget() # 新しい dockwidget を作成
 myNewFreeCADWidget.ui = myWidget_Ui() # UIスクリプトを読み込み
 myNewFreeCADWidget.ui.setupUi(myNewFreeCADWidget) # UIをセットアップ
 FCmw.addDockWidget(QtCore.Qt.RightDockWidgetArea,myNewFreeCADWidget) # メインウィンドウにウィジットを追加

コンボビューへのタブの追加

次のコードを使うとFreeCADのコンボビューの"Project"タブ、"Tasks"タブの隣にタブを追加することができます。またuiファイルを直接そのタブに読み込むためにuicモジュールを使用しています。

from PyQt4 import QtGui,QtCore
from PyQt4 import uic
#from PySide import QtGui,QtCore

def getMainWindow():
   "returns the main window"
   # QtGui.qApp.activeWindow()の使用は信頼性が高くありません。
   # これはメインウィンドウではなく別のウィジット（例えばダイアログ）が
   # アクティブな場合に間違ったウィジットが返されるためです
   toplevel = QtGui.qApp.topLevelWidgets()
   for i in toplevel:
       if i.metaObject().className() == "Gui::MainWindow":
           return i
   raise Exception("No main window found")

def getComboView(mw):
   dw=mw.findChildren(QtGui.QDockWidget)
   for i in dw:
       if str(i.objectName()) == "Combo View":
           return i.findChild(QtGui.QTabWidget)
   raise Exception("No tab widget found")

mw = getMainWindow()
tab = getComboView(getMainWindow())
tab2=QtGui.QDialog()
tab.addTab(tab2,"A Special Tab")
uic.loadUi("/myTaskPanelforTabs.ui",tab2)
tab2.show()

#tab.removeTab(2)

自作ウェブページを開く

import WebGui
WebGui.openBrowser("http://www.example.com")

開いたウェブページのHTMLコンテンツを取得

from PyQt4 import QtGui,QtWebKit
a = QtGui.qApp
mw = a.activeWindow()
v = mw.findChild(QtWebKit.QWebFrame)
html = unicode(v.toHtml())
print html

このページでは高度な機能を簡単にPythonで構築する方法を説明しています。このエクササイズではラインを描画する新しいツールを作ることにします。このツールはFreeCADコマンドに関連付けすることが可能で、そのコマンドはメニューアイテムやツールバーボタンなどのインターフェイスの任意の要素から呼び出すことができます。

メインスクリプト

まず必要な機能を全て持つスクリプトを書きましょう。それをファイルに保存してFreeCADでインポートすると書いたクラスと関数の全てをFreeCADで利用できるようになります。あなたのおこのみのテキストエディタを起動して次の様に入力してください：

import FreeCADGui, Part
from pivy.coin import *

class line:
    "this class will create a line after the user clicked 2 points on the screen"
    def __init__(self):
        self.view = FreeCADGui.ActiveDocument.ActiveView
        self.stack = []
        self.callback = self.view.addEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.getpoint)  

    def getpoint(self,event_cb):
        event = event_cb.getEvent()
        if event.getState() == SoMouseButtonEvent.DOWN:
            pos = event.getPosition()
            point = self.view.getPoint(pos[0],pos[1])
            self.stack.append(point)
            if len(self.stack) == 2:
                l = Part.Line(self.stack[0],self.stack[1])
                shape = l.toShape()
                Part.show(shape)
                self.view.removeEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.callback)

詳しい説明

import Part, FreeCADGui
from pivy.coin import *

Pythonでは別のモジュールの関数を使いたい場合にはそれをインポートする必要があります。今回はラインを作るためのPartモジュールの関数と3DビューにアクセスするためのGUIモジュール（FreeCADGui）の関数が必要になります。またSoMouseButtonEventなどのCoinオブジェクト全てを直接使用するのでCoinライブラリの全機能も必要になります。

class line:

ここでメインクラスを定義しています。なぜ関数でなくクラスを使うのでしょうか？それは私たちのツールはユーザーが画面をクリックするの待つ間、"生きて"いなければならないからです。関数はその処理が終わると終了してしまいますがオブジェクト（クラスによってオブジェクトが定義されます）は破棄されるまで生き続けます。

"this class will create a line after the user clicked 2 points on the screen"

Pythonでは全てのクラス、関数に説明文を設定することができます。これはFreeCADでは特に便利です。クラスをインタプリタで呼ぶとその説明文がツールチップ表示されるからです。

def __init__(self):

Pythonのクラスはいつでも__init__を持つことができます。__init__はオブジェクトを作成するためにクラスが呼ばれた時に実行されます。従って私たちのラインツールが開始された時にやりたいことは全てここに書きます。

self.view = FreeCADGui.ActiveDocument.ActiveView

クラスの中では通常は変数名の前にself.と付けた方がいいでしょう。そうすることでクラスの内外の全関数がわかりやすくなります。ここではself.viewを使ってアクティブな3Dビューへのアクセスと操作を行います。

self.stack = []

ここではgetpoint関数によって送信される3D上の点を入れる空のリストを作成しています。

self.callback = self.view.addEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.getpoint)

重要な部分です。実際のCoin3Dシーンだからです。FreeCADは特定のシーンイベントが起きるたびに関数を呼び出すためのCoinのコールバックの仕組みを使っています。今回はSoMouseButtonイベント用のコールバックを作成し、それをgetpoint関数と関連付けています。これによってマウスボタンが押されたり離されたりするたびにgetpoint関数が実行されます。

またaddEventCallbackPivy()の代わりにaddEventCallback()を呼べばpivyを利用しなくとも済みます。ただしpivyはCoinシーンの任意の部分にアクセスする非常に効率的で自然な方法なので、できるだけ使った方がいいでしょう！

def getpoint(self,event_cb):

次に3Dビューでマウスボタンが押されるたびに実行されるgetpoint関数を定義します。この関数はevent_cbと呼ばれる引数を受け取ります。このイベントコールバックから複数の情報が格納されているイベントオブジェクトにアクセスすることが可能です（モード情報はこちら）。

if event.getState() == SoMouseButtonEvent.DOWN:

getpoint関数はマウスボタンが押されるか離される時に呼ばれます。しかし私たちは押された時にだけ3D上の点をピックしたいのです（そうしないと互いに非常に近い二つの3D上の点を取得してしまうことになります）。そこでそれをチェックしなければなりません。

pos = event.getPosition()

ここではマウスカーソルのスクリーン座標を取得しています。

point = self.view.getPoint(pos[0],pos[1])

この関数はマウスカーソル下の焦点面の上にある3D上の点が格納されたFreeCADのVector (x,y,z)を返します。カメラ視点で言うとカメラから伸びる光線とマウスカーソル位置を通過し焦点面にぶつかるところを想像してください。それが取得される3D上の点です。正射影表示の場合にはその光線は視線方向と平行になります。

self.stack.append(point)

新しい点をスタックに追加しています。

if len(self.stack) == 2:

必要なだけの点はありますか？もしあればラインを描画しましょう！

l = Part.Line(self.stack[0],self.stack[1])

ここではFreeCADのVectro二つからラインを作成する関数であるPartモジュールのLine()関数を使用しています。Partモジュールの中で作ったり変更したりしたものは全てPartモジュールが保持します。ここまでで私たちはラインパートを作成しました。しかしまだアクティブなドキュメント上のオブジェクトに結び付けられていないので画面上には何も表示されません。

shape = l.toShape()

FreeCADドキュメントはPartモジュールから作成されたシェイプだけを受け取ることができます。シェイプはPartモジュールの最も一般的な型です。従って私たちはドキュメントに追加する前にラインをシェイプに変換しなければなりません。

Part.show(shape)

Partモジュールには非常に便利なshow()関数があり、それを使ってドキュメントに新しいオブジェクトを作ってそこにシェイプを結びつけることができます。あるいはまずドキュメントに新しいオブジェクトを作った後、手作業でシェイプを結びつけることもできます。

self.view.removeEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.callback)

ラインを使った作業が終わったので貴重なCPUサイクルを消費してしまうコールバックのための仕組みを取り除きましょう。

スクリプトのテストと使用

さて、それではスクリプトをFreeCADのPythonインタプリタが見える場所に保存しましょう。モジュールインポート時にインタプリタは次の場所を検索します：Pythonのインストールパス、FreeCADのbinディレクトリ、FreeCADモジュールディレクトリの全て。最もいい方法はFreeCADのModディレクトリの一つに新しいディレクトリを作成してそこにスクリプトを保存するというものです。例えば"MyScripts"ディレクトリをを作成してスクリプトを"exercise.py"として保存してみましょう。

これで準備万端です。FreeCADを起動して新しいドキュメントを作りPythonインタプリタで次のコマンドを実行しましょう：

import exercise

エラーメッセージが表示されなければ私たちの練習用スクリプトがロードされているはずです。次の様にしてその内容を調べて見ることができます：

dir(exercise)

dir()コマンドは組み込みのPythonコマンドでモジュールの内容をリスト表示することができます。私たちのline()クラスが待機しているのが確認できるはずです。それではテストしてみましょう：

exercise.line()

さらに3Dビューを二回クリックしてみると・・・ビンゴ。ラインが表示されます！もう一度行うには再度exercise.line()と入力します。何度でも繰り返せます・・・すごいと思いませんか？

FreeCADインターフェイスでのスクリプトの登録

さて私たちの新しいラインツールをもっとクールにするためにはインターフェイス上にボタンを付けるべきです。そうすれば毎回、キー入力を行う必要がなくなります。最も簡単な方法は新しく作ったMyScriptsディレクトリをちゃんとしたFreeCADワークベンチに作り変えるというものです。簡単にできます。必要なのはInitGui.pyというファイルをMyScriptsディレクトリの中に置くことだけです。InitGui.pyには新しいワークベンチを作り、そこに私たちの新しいツールを追加しろ、という命令を書きます。それから私たちの練習用コードをほんの少しだけ書き換えてline() ツールが公式なFreeCADコマンドとして認識されるようにする必要もあります。それではInitGui.pyファイルの作成からはじめましょう。次のコードをInitGui.pyファイルに書き込んでください：

class MyWorkbench (Workbench): 
   MenuText = "MyScripts"
   def Initialize(self):
       import exercise
       commandslist = ["line"]
       self.appendToolbar("My Scripts",commandslist)
Gui.addWorkbench(MyWorkbench())

もうあなたも上記のスクリプトが理解できるのではないかと思います。MyWorkbenchという名前の新しいクラスを作成してそこにタイトル（MenuText）を指定し、ワークベンチがFreeCADに読み込まれた時に実行されるInitialize()関数を定義しています。またその関数の中で私たちの練習用ファイルの内容を読み込み、内部で見つけたFreeCADコマンドをコマンドリストに追加します。それが終わったら"My Scripts"という名前のツールバーを作成し、コマンドリストをそこに代入するのです。もちろん今のところはツールは一つだけなので、コマンドリストに入っている要素は一つだけです。ワークベンチの用意が整ったらそれをメインインターフェイスに追加します。

ただしまだ動作を行うことはできません。FreeCADコマンドを動作されるためには特定のやり方でフォーマットする必要があるからです。つまり私たちのline()ツールを少しだけ変更する必要があるのです。新しいexercise.pyは次のようになります：

import FreeCADGui, Part
from pivy.coin import *
class line:
 "this class will create a line after the user clicked 2 points on the screen"
 def Activated(self):
   self.view = FreeCADGui.ActiveDocument.ActiveView
   self.stack = []
   self.callback = self.view.addEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.getpoint) 
 def getpoint(self,event_cb):
   event = event_cb.getEvent()
   if event.getState() == SoMouseButtonEvent.DOWN:
     pos = event.getPosition()
     point = self.view.getPoint(pos[0],pos[1])
     self.stack.append(point)
     if len(self.stack) == 2:
       l = Part.Line(self.stack[0],self.stack[1])
       shape = l.toShape()
       Part.show(shape)
       self.view.removeEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.callback)
 def GetResources(self): 
     return {'Pixmap' : 'path_to_an_icon/line_icon.png', 'MenuText': 'Line', 'ToolTip': 'Creates a line by clicking 2 points on the screen'} 
FreeCADGui.addCommand('line', line())

ここでは__init__()関数をActivated()関数に変更しています。FreeCADコマンドが実行されるときには自動でActivated()関数が実行されるためです。またGetResources()を追加しています。この関数はFreeCADにどこにツールのアイコンがあるのかとその名前、そして私たちのツールのツールチップを通知します。アイコンには任意のサイズのjpg、png、svgの画像が使用できますが最終的な外観に近い16x16、24x24、32x32といったサイズを使用するのが最も好ましいです。 最後にaddCommand()メソッドを使ってline()クラスを公式なFreeCADコマンドとして追加しています。

これで終わりです。FreeCADを再起動すれば真新しいラインツールのついたすてきな新しいワークベンチが使えます！

もっと知りたいですか？

このエクササイズが気にいったらこの小さなツールを改良してみましょう。できることはたくさんあります。例えば次のようなものがあります：

• ユーザーフィードバックの追加：今まで作ってきたのはとても原始的なツールです。ユーザーは恐らく使う時に少し迷うでしょう。ユーザーに次にどうしたら良いかを教えるフィードバックを何か追加してみましょう。例えばFreeCADのコンソールにメッセージを表示することができます。FreeCAD.Consoleモジュールを見てください。
• 手入力で3D上の点の座標を入力できるようにする。Pythonのinput()関数を参考にしてみてください。
• 2点以上の点を追加できるようにする。
• 他のイベントも追加してみる：今のところはマウスボタンイベントだけしかチェックしていませんがマウスが移動した時にも何か行なってみてはどうでしょう？例えば現在の座標を表示したりできるでしょう。
• 作成したオブジェクトに名前を付けてみる

疑問やアイデアがあれば遠慮せずにforumに書き込んでください！

このページではQtのインナーフェイスデザイン用の公式ツールであるQtDesignerを使って簡単なQtダイアログを作成し、それをPythonコードに変換してFreeCAD内部で使用する方法について説明します。この例ではPythonスクリプトの編集と実行の仕方、ディレクトリの移動などのターミナルウィンドウでの簡単な操作については既に知っているものとして説明を行います。また当然のことながらpyqtをインストールしてなければなりません。

ダイアログのデザイン

CADアプリケーションでは優れたUI（ユーザーインターフェイス）のデザインは非常に重要です。ユーザーが行う操作のほとんど全てがダイアログボックスの文章を読んだり、ボタンを押したり、アイコンを選択したりといったインターフェイスを通じたものになります。従って自分が何をしたいのか、ユーザーにどのような操作をさせたいのか、処理の流れがどのようになるのかを慎重に考えることがとても重要になってきます。

インターフェイスをデザインする際に知っておく必要のある概念がいくつかあります：

• モーダル/モーダレスなダイアログ： モーダルダイアログは画面の前面に表示されメインウィンドウの操作をできなくした上でユーザーにダイアログを操作するように要求します。一方、モーダレスダイアログはメインウィンドウの操作を妨げることはしません。どちらが良いかは時と場合によります。
• 何が必須であり何がオプションであるかを認識する：何をしなければならないユーザーが間違いなくわかるようにします。全てのものに適切な説明が書かれたラベルを付ける、ツールチップを使用するなどの方法があります。
• コマンドとパラメータの分離：通常、これはボタンとテキスト入力フィールドを使って行われます。ボタンをクリックすると処理が行われ、テキストフィールド内部の値を変更すると何かしらのパラメータが変更されるということをユーザーは理解しています。現在ではユーザーは通常、ボタンが何か、入力フィールドが何かといったことを熟知しているのです。私たちが使用するインターフェイスツールキットであるQtは最先端のツールキットです。どうやればわかりやすいものを作れるか悩む必要はほとんどありません。既にそれ自体がわかりやすい様になっているのです。

さてこれからやることについては十分な定義が終わりました。いよいよQtDesignerを開きます。次の様な非常に簡単なダイアログをデザインしてみましょう：

出来上がったらFreeCADできれいな長方形の平面を作成するためにこのダイアログを使うことにします。きれいな長方形の平面を作るのにはこれは不便だということにあなたは気がつくでしょうが、後でもっと複雑なことを行えるように変更することは簡単です。QtDesignerを開くと次のような表示になります：

使い方は非常に簡単です。左側のバーにはウィジット上にドラッグして置ける要素があります。右側には選択されている要素の編集可能なプロパティ全てが表示されているプロパティパネルがあります。それではまず新しいウィジットを作成することから始めてみましょう。デフォルトのOK/キャンセルボタンはいらないので"Dialog without buttons"を選択します。次にLabelウィジットを3つドラッグしてきます。一つはタイトル、一つは "Height"、一つは"Width"と書くために使います。ラベルはウィジット上に表示されるシンプルなテキストでユーザーに情報を与えるために使います。ラベルを選択すると右側にフォントスタイル、高さなどいくつかの変更可能なプロパティが表示されます。

次にユーザーが入力することが可能なテキストフィールドであるLineEditsを2つ追加します。一つは高さ用、もう一つは幅用です。ここでもプロパティを編集することができます。例えばデフォルト値を設定してみてはどうでしょう？それぞれ1.00としてみましょう。こうすればユーザーがダイアログを見た確認した時には既に両方の値が設定されていて、ユーザーがその値に満足していれば直接ボタンを押すことができるので貴重な時間を節約できます。さらにユーザーが2つのフィールドに入力した後に押す必要があるPushButtonを追加します。

ここでは非常に簡単なコントロールを選んでいますがQtにもっと多くのオプションがあり、LineEditの代わりにSpinboxeを使ったりすることなどもできます。何が利用可能か見てみてください。きっと他のアイデアが思い浮かぶはずです。

QtDesignerで行うことはこれで全てです。ただし、最後に全ての要素の名前をわかりやすいものに変更しておきましょう。そうすればスクリプトで区別がつきやすくなります：

ダイアログのPythonコードへの変換

さあ、私たちのウィジットをどこかに保存しましょう。ウィジットは.uiファイルとして保存され、pyuicを使うと簡単にPythonスクリプトに変換できます。Windowsではpyuicはpyqtにバンドルされています（確認してください）。Linuxではパッケージマネージャで個別にインストールする必要があるはずです（Debianベースのパッケージの場合、pyqt4-dev-toolsパッケージに含まれています）。変換のためにはまずターミナルウィンドウ（Windowsの場合はコマンドプロンプトウィンドウ）を開き、.uiファイルを保存した場所に移動して次のコマンドを実行します：

pyuic mywidget.ui > mywidget.py

一部のシステムではプログラム名がpyuicではなくpyuic4の場合があります。このコマンドによって.uiファイルがPythonスクリプトに変換されます。mywidget.pyファイルを開いて見てみるとその内容が簡単に理解できるものであることがわかります：

from PyQt4 import QtCore, QtGui

class Ui_Dialog(object):
    def setupUi(self, Dialog):
        Dialog.setObjectName("Dialog")
        Dialog.resize(187, 178)
        self.title = QtGui.QLabel(Dialog)
        self.title.setGeometry(QtCore.QRect(10, 10, 271, 16))
        self.title.setObjectName("title")
        self.label_width = QtGui.QLabel(Dialog)
        ...

        self.retranslateUi(Dialog)
        QtCore.QMetaObject.connectSlotsByName(Dialog)

   def retranslateUi(self, Dialog):
        Dialog.setWindowTitle(QtGui.QApplication.translate("Dialog", "Dialog", None, QtGui.QApplication.UnicodeUTF8))
        self.title.setText(QtGui.QApplication.translate("Dialog", "Plane-O-Matic", None, QtGui.QApplication.UnicodeUTF8))
        ...

見てわかるようにとても簡単な構造です。Ui_Dialogという名前のクラスが作成され、その中にウィジットのインターフェイス要素が保存されています。クラスは二つのメソッドを持っています。一つはウィジットをセットアップするためのもので、もう一つはその内容を翻訳するためのものです。翻訳用のものはインターフェイス要素を翻訳するために用意された一般的なQtの仕組みの一部です。セットアップ用のメソッドは私たちがQtDesignerで定義したウィジットを1つずつ作成し、先に私たちが決めたオプションを設定していきます。それからインターフェイス全体が翻訳され、最後にスロットが接続されます（これについては後で説明します）。

これで新しいウィジットを作成し、そのインターフェイスを作成するためにこのクラスを使用することができます。もう既にウィジットを動かしてみることができます。FreeCADが検索する場所（FreeCADのbinディレクトリまたはModサブディレクトリのどれか）にmywidget.pyファイルを置き、FreeCADのPythonインタプリタで次のコマンドを実行すればいいのです：

from PyQt4 import QtGui
import mywidget
d = QtGui.QWidget()
d.ui = mywidget.Ui_Dialog()
d.ui.setupUi(d)
d.show()

するとダイアログが表示されます！Pythonインタプリタがまだ動作していることに注意してください。私たちはモーダレスダイアログを使っているのです。ダイアログを閉じるには次のコマンドを使ってください（もちろんダイアログの閉じるアイコンをクリックしても閉じられます）：
d.hide()

ダイアログで処理を行えるようにする

さてダイアログの表示と非表示はできるようになりました。最後の仕上げを行いましょう：処理を行えるようにするのです！QtDesignerを少しいじっていればすぐに"signals and slots"と呼ばれる機能があることに気がつくでしょう。基本的な動作は次のようになります。ウィジット上の要素（Qtでの用語で言うとこれらの要素自体もウィジットなのです）はシグナルを送信できます。シグナルはウィジットの型によって異なります。例えばボタンは押された時と離された時にシグナルを送れます。このシグナルはスロットにつなげることができます。スロットとしては他のウィジットの特別な機能（例えばダイアログには"閉じる"スロットがあり、閉じるボタンからのシグナルを接続することができます）や自作関数を使うことができます。PyQtリファレンスドキュメントには全てのQtウィジット、それを使ってできること、どんなシグナルを送信できるかなどがリストアップされています。

ここで行うことは高さと幅に基いて平面を作成する新しい関数を作成すること、その関数と"Create!"ボタンを押した際に発信されるシグナルとを接続することです。まずFreeCADモジュールをインポートすることから始めましょう。次の行をQtCoreとQtGuiをインポート済みのスクリプトの先頭に書き込むことで可能です：

import FreeCAD, Part

次にUi_Dialogクラスに新しい関数を追加しましょう：

def createPlane(self):
    try:
        # まず有効な値が入力されているかをチェック
        w = float(self.width.text())
        h = float(self.height.text())
    except ValueError:
        print "Error! Width and Height values must be valid numbers!"
    else:
        # 4つの点から面を作成
        p1 = FreeCAD.Vector(0,0,0)
        p2 = FreeCAD.Vector(w,0,0)
        p3 = FreeCAD.Vector(w,h,0)
        p4 = FreeCAD.Vector(0,h,0)
        pointslist = [p1,p2,p3,p4,p1]
        mywire = Part.makePolygon(pointslist)
        myface = Part.Face(mywire)
        Part.show(myface)
        self.hide()

さらにボタンと関数を接続するようにQtに指定する必要があります。次の行をQtCore.QMetaObject.connectSlotsByName(Dialog)の直前に挿入することで可能です：

QtCore.QObject.connect(self.create,QtCore.SIGNAL("pressed()"),self.createPlane)

見てわかるようにこれによって私たちが作成したオブジェクト（"Create!"ボタン）のpressed()シグナルが私たちが定義したcreatePlaneという名前のスロットに接続されます。これで終わりです！最後に呼び出しを簡単に行うためにダイアログを作成するための小さな関数を追加しましょう。Ui_Dialogクラスの外に次のコードを追加します：

class plane():
    d = QtGui.QWidget()
    d.ui = Ui_Dialog()
    d.ui.setupUi(d)
    d.show()

それが終わったらFreeCADから次のコマンドを実行するだけです：

import mywidget
mywidget.plane()

これで終わりです。もうあなたは自分のウィジットをFreeCADのインターフェイスに追加したり、ウィジット上の他の要素を使ってもっと高度な自作ツールを作るといったあらゆることに挑戦できるのです。

全スクリプト

参考のために全スクリプトを記載しておきます：

# -*- coding: utf-8 -*-

# フォームの実装は読み込んだ'mywidget.ui'ファイルから生成
#
# Created: Mon Jun  1 19:09:10 2009
#      by: PyQt4 UI code generator 4.4.4
#
# 警告！このファイルで行った全ての変更が失われます！

from PyQt4 import QtCore, QtGui
import FreeCAD, Part 

class Ui_Dialog(object):
   def setupUi(self, Dialog):
       Dialog.setObjectName("Dialog")
       Dialog.resize(187, 178)
       self.title = QtGui.QLabel(Dialog)
       self.title.setGeometry(QtCore.QRect(10, 10, 271, 16))
       self.title.setObjectName("title")
       self.label_width = QtGui.QLabel(Dialog)
       self.label_width.setGeometry(QtCore.QRect(10, 50, 57, 16))
       self.label_width.setObjectName("label_width")
       self.label_height = QtGui.QLabel(Dialog)
       self.label_height.setGeometry(QtCore.QRect(10, 90, 57, 16))
       self.label_height.setObjectName("label_height")
       self.width = QtGui.QLineEdit(Dialog)
       self.width.setGeometry(QtCore.QRect(60, 40, 111, 26))
       self.width.setObjectName("width")
       self.height = QtGui.QLineEdit(Dialog)
       self.height.setGeometry(QtCore.QRect(60, 80, 111, 26))
       self.height.setObjectName("height")
       self.create = QtGui.QPushButton(Dialog)
       self.create.setGeometry(QtCore.QRect(50, 140, 83, 26))
       self.create.setObjectName("create")

       self.retranslateUi(Dialog)
       QtCore.QObject.connect(self.create,QtCore.SIGNAL("pressed()"),self.createPlane)
       QtCore.QMetaObject.connectSlotsByName(Dialog)

   def retranslateUi(self, Dialog):
       Dialog.setWindowTitle(QtGui.QApplication.translate("Dialog", "Dialog", None, QtGui.QApplication.UnicodeUTF8))
       self.title.setText(QtGui.QApplication.translate("Dialog", "Plane-O-Matic", None, QtGui.QApplication.UnicodeUTF8))
       self.label_width.setText(QtGui.QApplication.translate("Dialog", "Width", None, QtGui.QApplication.UnicodeUTF8))
       self.label_height.setText(QtGui.QApplication.translate("Dialog", "Height", None, QtGui.QApplication.UnicodeUTF8))
       self.create.setText(QtGui.QApplication.translate("Dialog", "Create!", None, QtGui.QApplication.UnicodeUTF8))

   def createPlane(self):
       try:
           # まず有効な値が入力されているかをチェック
           w = float(self.width.text())
           h = float(self.height.text())
       except ValueError:
           print "Error! Width and Height values must be valid numbers!"
       else:
           # 4つの点から面を作成
           p1 = FreeCAD.Vector(0,0,0)
           p2 = FreeCAD.Vector(w,0,0)
           p3 = FreeCAD.Vector(w,h,0)
           p4 = FreeCAD.Vector(0,h,0)
           pointslist = [p1,p2,p3,p4,p1]
           mywire = Part.makePolygon(pointslist)
           myface = Part.Face(mywire)
           Part.show(myface)

class plane():
    d = QtGui.QWidget()
    d.ui = Ui_Dialog()
    d.ui.setupUi(d)
    d.show()

FreeCAD用のアプリケーションの開発

管理人の声明文

オープンソースのための「正しい」ライセンスについての議論がインターネットのかなりのバンド幅をを占めてきたことは承知していますが、ここでもFreeCADがそのひとつを採用すべきである理由について、私の意見を述べます。

私はこのプロジェクトのためにLGPLを選びました。LGPLの短所と長所は分かっていますので、その理由を説明したいと思います。

FreeCADはライブラリとアプリケーションの混合物なのでGPLでは少々強すぎます。GPLだと、FreeCADの基盤ライブラリとのリンクを妨げてしまうため、FreeCADの商用モジュールが作成できなくなります。何故商用モジュールなのだろうと思われるかもしれません。これはLinuxが良い例です。もしGNU CライブラリがGPLで、非GPLのアプリケーションにリンクできなかったとしたら、Linuxはこれほど成功したでしょうか？私はLinuxの自由さが大好きです、けれども同時にNVIDIAの最高の3Dグラフィックドライバを使用できるようにして欲しいとも思っています。NVIDIAがドライバのコードの公開を望まない理由もよく分かりますし納得しています。私たちは企業のために働いており、報酬や少なくとも糧が必要なのです。だから私にとって、オープンソースとクローズドソースソフトウェアとの共存は、LGPLの規則に従っている限りは、悪いことではありません。私は、誰かがFreeCADのためのCATIAのインポート・エクスポートプロセッサを書き、それを無料や有料で配布するのを見たいのです。彼が望む以上の公開を強制したくはありません。それは彼のためにもFreeCADのためにも良いことにはならないでしょう。

とはいえ、この決定はFreeCADのコアシステムにのみ行われるものです。アプリケーションモジュールの作者は、自分自身でそのライセンスを決定できます。

使用ライセンス

FreeCADは以下のライセンスに従って公開されています：

Lesser General Public Licence (LGPL2+)

コアライブラリのライセンスです。src/App、src/Gui、sui/Baseに含まれる.hと.cppと記載されたファイル、src/Modに含まれるほとんどのモジュール、実行プログラムのためのsrc/main内の.hと.cppと記載されたファイルが該当します。またアイコンと画像もLGPLです。

Open Publication License

http://free-cad.sourceforge.net/ 上の、作成者の特別な表記がないドキュメントのライセンスです。

FreeCADが使用しているライセンスの詳細についてはDebian著作権ファイルを参照してください。

ライセンス上の副作用

バージョン0.13までのところ、そのソース自体にはLGPL2+ライセンスが適用されるもののFreeCADはGPL2+ライセンスで配布されています。これはCoin3D（GPL2）とPyQt（GPL）をリンクしているためです。しかし0.14からは完全にGPLライセンスから自由になれる予定です。PyQtはPySideに置き換えられる予定であり、Coin3DはBSDライセンスで再ライセンスされました。ライセンス上の残る問題はOCTPL (Open CASCADE Technology Public License)だけです。いくつかの違いはありますがこれはほとんどLGPLと同じライセンスです。創始者のRoman Lyginが彼のブログでこのライセンスについて詳しく述べています。独自に作成されたOCTPLライセンスはFreeCADに対してさまざまな副作用を引き起こしており、これについてはOpenCasCadeフォーラムなどさまざまなフォーラムやメーリングリストで幅広い議論が行われています。その中でも最も大きな問題に関しての記事をいくつか紹介しておきます。

GPL2/GPL3/OCTLPは非互換

私たちが最初に問題に気がついたのはFSFの最重要プロジェクトディスカッションリストによってです。それは私たちが調査していたGPL3でライセンスされているライブラリについてのものでした。当時はGPL2のみのCoin3Dをリンクしていたのでそのライブラリを採用することはできませんでした。またOCTPLもGPL非互換であると考えられています。このLibreGraphicsWorldの記事"LibreDWG drama: the end or the new beginning?"ではLibreDWGプロジェクトがFreeCADやLibreCADで受け入れられなかった事の顛末を紹介しています。

Debian

OCTPLの非互換性についてはDebianの法問題リストで議論され、それがFreeCADパッケージについてのバグレポートを招きました。これはDebianテスト版からメインディストリビューションへの移行を妨げるもの（ignore-tag）です。しかしGPLコードとライブラリから解放されたFreeCADは受け入れられるはずであることも付け加えておきましょう。再ライセンスされたCoin3D V4とPyQtの置き換えによって0.14のリリースではGPLフリーに到達することでしょう。

Fedora/RedHatでの不自由

FedoraプロジェクトではOpenCasCadeは"不自由（非フリー）"のリストに入れられています。つまり基本的にはFedora、RedHatに取り入れられることはありません。またこれはOCCがそのライセンスを変えるまではFreeCADがFedora、RedHatに取り入れられることはないということです。このライセンスに対する評定をリンクしておきます：

• Fedora法問題リストでの議論
• RedHatバグトラッカーでライセンスレビューのエントリ　

私の理解では主な障害は有償サポートを行いたいと思った場合にOCCライセンスが非差別的なサポート料金を要求しているということです。これは "フリー"であることやオープンソースとは関係なく、RedHatのビジネスモデルでの問題なのです！

ライセンスの影響

個人ユーザー

個人ユーザーは無料でFreeCADを使用できます。基本的にはしたいことが何でもできるはずです....

職業的ユーザー

個人的、職業的を問わずどのような仕事のためでも自由にFreeCADを使うことができます。アプリケーションは好きなようにカスタマイズ可能です。オープン、クローズドを問わず、FreeCADの拡張ソースを作成することができます。作成者は常にそのデータの主人であり、FreeCADの更新や使用方法の変更を強要されることはありません。FreeCADの使用によって、いかなる種類の契約や義務を負うことはありません。

オープンソースの開発者

特別な目的のための独自拡張モジュールの土台としてFreeCADを使用することができます。開発者は、独占的なソフトウェアに対する自分の成果の使用許可を、GPLとLGPLから選択することができます。

商用開発者

商用開発者は、特別な目的のための独自拡張モジュールの土台としてFreeCADを使用することができ、そのモジュールのオープンソース化を強要されることはありません。開発者はLGPLを使用するすべてのモジュールを使用することができます。また自分の独占的なソフトウェアと一緒にFreeCADを配布することが許されます。一方通行ではないかぎり、開発者は原作者達からのサポートを得られるでしょう。

バグを報告する

近年、sourceforgeプラットフォームにより、プロジェクトのバグトラッカーアプリケーションmantis bug tracker が作られ、FreeCADは、古いビルトインのバグトラッカーの代わりに、現在このバグトラッカーを使っています。私たちのバグトラッカーのアドレスは、次のとおりです。:

http://www.freecadweb.org/tracker/main_page.php

もし、バグを発見したかもと思ったら、そこにバグを報告することは歓迎されます。しかし、バグを報告する前に、以下の項目をチェックしてください。:

• あなたの見つけたバグが本当にバグかどうか、つまり動くべき機能が動かないことを確認してください。

　あなたがわからない場合は、ためらわずに フォーラム にこの問題を説明し、何をすればよいか訪ねてください。

• 投稿する前に、frequently asked questions を読み、フォーラム 内を検索し、バグトラッカーを検索して、同じバグがまだ投稿されてないことを確認してください。
• できるだけ詳しく、問題や再現方法について説明してください。バグを確認できない場合、修正できなことがあります。
• あなたが使用しているオペレーティングシステムが32bitか64bitか、　あなたが使っているFreeCADのバージョンについての情報を付け加えてください。
• バグ毎に個別のレポートを投稿してください。
• FreeCADをinux上で利用し、バグが原因でクラッシュした場合は、デバッグトレースを実行することもできます。端末からgdb freecadを実行（gdbパッケージがインストールされていることを仮定）し、gdbの中でrunを実行します。　FreeCADは実行されます。クラッシュが発生したら、btと入力するとバックトレースを取得できます。投稿するバグレポートの中にバックトレースを含めてください。

機能追加要望

実装されていない機能をFreeCADで使いたいと思ったら、それはバグではなく、機能追加要望です。これは同じトラッカー（バグではなく機能要望として申請する）に投稿できますが、あなたの機能追加要望が実現される保証が無いことを心に留めておいてください。

パッチの投稿　

バグフィックスを作成した、FreeCADで公共利用できる拡張機能を作成した場合には、Subversionのdiffツールを使ってパッチを作成し、同じトラッカーに（バグフィックスとして）投稿してください。

"古い"sourceforgeのトラッカー(廃止)

注意：バグを報告するために、新しいMantisバグトラッカーを利用してください。この方法は現在廃止予定です。

どこで見つけるか？

FreeCADには独自の トラッカー要約ページ があります。そこではトラッカーの個々のセクションの概要を見ることができます。

いつ使用するか？

The FreeCAD Bug Tracker

バグ

もしバグを発見したかもしれないと思う場合は、トラッカーの Bugs Section に行き、statusをanyにして、これまでに申請されたバグを確認してください。キーワード検索を利用すると、似ている問題のバグトラッカーのエントリを見つけることができます。もし、あなたの問題が過去の項目になかったときは、同じページに新たな項目として投稿すべきです。

機能追加要求

あなたがFreeCADを世界で一番のCADソフトウェアにするために絶対に必要と思う機能がないことに気づいたら、Feature Request 機能追加要望のセクションが役に立つかもしれません。

サポート要求

あなたがFreeCADをコンパイルするのにどうすることもできず、 Compile On Windows や Compile On Unix にヒントとなるものが書かれていない場合や、他の新しい環境への移植を試す場合や、FreeCADの新しいモジュールや拡張機能を作る場合に、補助が必要な場合は、Support Requests セクションがあなたの行くべき場所になります。

新しいパッチ

バグの修正や、拡張機能、一般公開できるFreeCADの何らかを作成したときは、Subversioを使ってパッチを作成し、 patches section セクションにファイルを投稿してください。

この記事では、Windows上でFreeCADをコンパイルする方法を順番にで説明しています。

前提条件

必要なのは、主にコンパイラです。Windows上で我々は最新のサービスパックを適用したMS VisualStudio 8コンパイラ（またはVC++ Express）を使用しています。CygwinやMinGWのgccを使用するのはたぶん可能ですが、今までのところ試されたり移植されたりしていません。我々はVC8 Express Editionを使用するように移植しました。あなたは例えばWindows.hを得るために、Windows Platform SDKをダウンロードする必要があります。また、あなたは正常にFreeCADをコンパイルするために、すべてのサードパーティ製のライブラリが必要です。

あなたがMSのコンパイラーを使用する場合、Windows上でFreeCADを構築するために必要なすべてのLIBSを提供するFreeCAD LibPackをダウンロードするでしょう。

その他の前提条件は、（および有用なプログラム）は以下のとおりです。:

• cMake
• TortoiseGit
• Python 2.6
• WiX (Windows installer XML v3.0) - msiインストーラを作りたい場合

　システムパスに、以下のプログラムへのパスを加えることも必要です。:

• Libpack
• git (TortoiseGitではなく、git.exe)
• python

cMakeを用いたビルド

　まず、 cMakeをダウンロードしてビルドマシンにインストールします。

cMakeへの切り替え

バージョン0.9から、様々なコンパイラのためのbuild/makeファイルを生成するのに cMakeを利用します。我々は、.vcproj ファイルをもう提供しません。もし、以前のバージョンのFreeCAD(バージョン0.8以前)をビルドしたい場合、この記事の後ろにある"以前のバージョンのビルド"を参照して下さい。

我々は30を超えるビルド対象や様々なコンパイラへの対応のためのプロジェクトファイルを維持するのが苦痛になってきたので切り替えました。cMakeを使うことで、我々はまだ主として使うコンパイラはMS VC9 Expressですが、Code::Blocks、Qt CreaterやEclipse CDT等の代替IDEを使用できる可能性がでてきました。 将来的には商標権のあるコンパイラソフトウェアを利用せずに、Windows上でビルドすることを計画しています。

ビルドプロセスの設定

CMakeのでFreeCADを構築するための最初のステップは、環境を構成することです。これには基本的に以下の２つの方法があります。:

• LibPackを利用する
• 必要なライブラリをすべてインストールして、cMakeにそれらを見つけてもらう。

前者の方法では、あなたはLibPackのパスをcMakeで設定するだけでよく、残りの部分は自動的に実行され、以下のような画面が表示されます。:

LibPackのパスが 変数 FREECAD_LIBPACK_DIR に設定されていることを確認してください。すべてのincludeとパスが設定されいることから始めます。あなたはただ Generate ボタンを押す必要があり、プロジェクトファイルが生成されます。

もし FREECAD_LIBPACK_USE オプションをoffにした場合、設定はあなたのシステム内から全ての必要なライブラリを探します。多かれ少なかれ、うまくいくかどうかはライブラリに依存します。そのため、幾つかのパスは手動で定義する必要がしばしばあります。cMakeは、見つからないものや、指定すべきものをあなたに指摘します。

ビルド処理のオプション

cmakeのビルドシステムは、ビルドプロセス上で多くの柔軟性を私たちに提供します。　これは、我々はいくつかの機能またはモジュールをオフに切り替えることができるということです。これはLinuxのカーネルビルドに似ています。ビルドプロセスを決定するために、多くのスイッチがあります。

以下はスイッチの説明です。我々はビルドの柔軟性をより向上させたいので、これらは将来的には大きく変更する可能性が高いです。

cMake と Visual Studio 2008を使う方法

まずCMakeのGUIを起動し、ソースフォルダを選択しインストール先のフォルダを追加し、 "設定"をクリックしてください。CMakeはジェネレータを選択するように求められます - FreeCADのお勧めは "Visual Studio 9 2008"です。

"次へ"ボタンをクリックした後、LibPackを見つけることができないため、CMakeはエラーを出力します。 "FREECAD_LIBPACK_DIR"変数にどこにLibpackフォルダがあるかを手動で選択する必要があります。その後、もう一度 "設定"をクリックする必要があります。configureが行われた後、 "Generate"をクリックしてください。cMakeの作業を終了後、それを閉じることができます。

Visual Studioを使用する前に、我々は（最初に構築する際に、一度だけこれを行う必要がある）システムパスにlibpackを追加する必要があります。あなたは "Panel>>System>>Advanced System Settings"をたどる必要があります。"System properties"ダイアログで、 "Advanced"タブの下に"Environment Variables"ボタンがあります。それをクリックしてください。それをクリックした後、パスにlibpackを追加します。他のパス変数とは";"で区別します。

次にVisual Studio 2008 を起動する必要があります。Visual C++ Express2008でも同様に動作します。ビルドの前に、binフォルダを libpack¥bin フォルダから、(cMakeで生成された)binフォルダにコピーするのは良い手順です。

この後、"File >> Open >> Project/Solution"をたどってください。cMakeのビルドで生成されたファイルから、FreeCAD_Trunk.slnを開く必要があります。それを開いたら、ツールバーにある3つのポップアップメニューがあるでしょう。それらの一つは"Debug"になっています。これを"Release"に切り替えます。"Build >> Build Solution"を実行します (もしくは F7キーを押します) 。このプロセスにはかなりの時間がかかります。

それが終了したら、"Debug >> Start without Debugging"を実行します。ポップアップウィンドウに、exeファイルを選択するように求められます。　"Executable File Name" の下にあるポップアップメニューをクリックし、"Browse"を選択します。ソースファイルがあるbinフォルダに移動し、FreeCAD.exeを選択します。

作業完了です!

コマンドラインビルド

ここではコマンドラインからFreeCADを構築する例を示します。:

rem @echo off
rem   Build script, uses vcbuild to completetly build FreeCAD

rem update trunc
d:
cd "D:\_Projekte\FreeCAD\FreeCAD_0.9"
"C:\Program Files (x86)\Subversion\bin\svn.exe" update 

rem  set the aprobiated Variables here or outside in the system

set PATH=C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem
set INCLUDE=
set LIB=

rem Register VS Build programms
call "C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\vcvarsall.bat"

rem Set Standard include paths
set INCLUDE=%INCLUDE%;%FrameworkSDKDir%\include
set INCLUDE=%INCLUDE%;C:\Program Files\Microsoft SDKs\Windows\v6.0A\Include

rem Set lib Pathes
set LIB=%LIB%;C:\Program Files\Microsoft SDKs\Windows\v6.0A\Lib
set LIB=%LIB%;%PROGRAMFILES%\Microsoft Visual Studio\VC98\Lib

rem Start the Visuall Studio build process
"C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\vcpackages\vcbuild.exe" "D:\_Projekte\FreeCAD FreeCAD_0.9_build\FreeCAD_trunk.sln" /useenv

以前のバージョンのビルド

LibPackの使用

FreeCADのコンパイルを簡単にするために、我々はすべての必要なライブラリのコレクションを提供しています。それは、LibPackと呼ばれています。あなたはそれをSourceForgeの ダウンロードページ で見つけることができます。

あなたは、以下の環境変数を設定する必要があります。:

FREECADLIB = "D:\Wherever\LIBPACK"

QTDIR = "%FREECADLIB%"

％FREECADLIB％\ bin"および"％FREECADLIB％\ dll"の場所を、システムPATH変数に追加します。Windowsは再帰的に環境変数を置き換えないので、"％FREECADLIB％"をパス名で付け替える必要があることに留意してください。

Visual Studioでのディレクトリセットアップ

Visual Studioの幾つかのサーチパスをセットする必要があります。 これらを変更するには、Tools→Options→Directory とメニューをたどります。

Includes

以下のサーチパスをincludeパスのサーチリストに追加します。

•  %FREECADLIB%\include
•  %FREECADLIB%\include\Python
•  %FREECADLIB%\include\boost
•  %FREECADLIB%\include\xercesc
•  %FREECADLIB%\include\OpenCascade
•  %FREECADLIB%\include\OpenCV
•  %FREECADLIB%\include\Coin
•  %FREECADLIB%\include\SoQt
•  %FREECADLIB%\include\QT
•  %FREECADLIB%\include\QT\Qt3Support
•  %FREECADLIB%\include\QT\QtCore
•  %FREECADLIB%\include\QT\QtGui
•  %FREECADLIB%\include\QT\QtNetwork
•  %FREECADLIB%\include\QT\QtOpenGL
•  %FREECADLIB%\include\QT\QtSvg
•  %FREECADLIB%\include\QT\QtUiTools
•  %FREECADLIB%\include\QT\QtXml
•  %FREECADLIB%\include\Gts
•  %FREECADLIB%\include\zlib

Libs

以下のサーチパスをlibパスのサーチリストに追加します。

•  %FREECADLIB%\lib

Executables

以下のサーチパスをexecutableパスのサーチリストに追加します。

•  %FREECADLIB%\bin
• TortoiseSVN バイナリをインストールしたディレクトリ、 普段は "C:\Programm Files\TortoiseSVN\bin", これは SubWVRev.exe が Subversionからバージョン番号を抽出する分散ビルドの時に必要です 。

Pythonの必要性

コンパイル時にいくつかのPythonスクリプトが実行されます。そのため、PythonインタプリタはOS上で動作しなければいけません。それを確認するには、コマンドボックスを使用します。Pythonのライブラリが正しくインストールされていない場合は、"python.exeを見つけることができません"といったエラーメッセージが表示されます。あなたはLibPackを使用する場合もbinディレクトリでpython.exeを使用することができます。

VC8での注意事項

VC6とVC8ではバージョンが異なるため、VC8でプロジェクトをビルドする場合、WildMagicライブラリのリンク情報を変更する必要があります。両方のバージョンは"LIBPACK/DLL"で提供されています。AppMeshのプロジェクトのプロパティで、wm.dllのライブラリ名をVC8バージョンに変更します。DebugとReleaseの構成で、それを変えることを忘れないでください。

コンパイル

すべての前提条件に適合させたあとは、コンパイルはVC内でマウスクリックするだけでできると思います。

コンパイル後

すべての前提条件に適合した後、コンパイルは - うまくいけば - VCではでマウスクリックのみで実行できます。:

• python.exe and python_d.exe from LIBPACK/bin
• python25.dll and python25_d.dll from LIBPACK/bin
• python25.zip from LIBPACK/bin
• make a copy of Python25.zip and rename it to Python25_d.zip
• QtCore4.dll from LIBPACK/bin
• QtGui4.dll from LIBPACK/bin
• boost_signals-vc80-mt-1_34_1.dll from LIBPACK/bin
• boost_program_options-vc80-mt-1_34_1.dll from LIBPACK/bin
• xerces-c_2_8.dll from LIBPACK/bin
• zlib1.dll from LIBPACK/bin
• coin2.dll from LIBPACK/bin
• soqt1.dll from LIBPACK/bin
• QtOpenGL4.dll from LIBPACK/bin
• QtNetwork4.dll from LIBPACK/bin
• QtSvg4.dll from LIBPACK/bin
• QtXml4.dll from LIBPACK/bin

バージョン2.5よりも古いPythonを使用したLibPackを使っている場合、さらに2つのファイルをコピーする必要があります。:

• zlib.pyd and zlib_d.pyd from LIBPACK/bin/lib. This is needed by python to open the zipped python library.
• _sre.pyd and _sre_d.pyd from LIBPACK/bin/lib. This is needed by python for the built in help system.

Pythonエラーで実行できない場合は、zlib*.pyd ファイルの一つが不足しています。

その他のもの

ソースコードのドキュメントを構築する場合は、 DoxyGenが必要です。

インストーラパッケージを作成するには WIXが必要です。

コンパイル時にいくつかのPythonスクリプトが実行されます。そのため、Pythonインタプリタが適切に動作する必要があります。

詳細は ソース内の"README.Linux"にも記載があります。

まずはじめに、Qt Designer用のFreeCADのすべてのカスタムヴィジェットを提供するQtプラグインを構築すべきです。ソースファイルは以下にあります。

//src/Tools/plugins/widget//.

これまでのところ我々は、makefileを提供していません。しかし、以下を実行すると、

qmake plugin.pro

makefileが作成されます。これを実行後、makeを実行するとライブラリが作成されます。

//libFreeCAD_widgets.so//.

このライブラリをQt Designerに認識させるために、以下の場所にファイルをコピーする必要があります。

//$QTDIR/plugin/designer//.

最近のLinuxディストリビューションでは、すべての依存パッケージがパッケージマネージャで提供されるので、FreeCADのビルドは簡単です。基本的には以下の３ステップです。

1) FreeCADのソースコードを取得
2) 依存関係を取得 (FreeCADが依存するパッケージ)
3) "cmake . && make"でのコンパイル

以下は、全体のプロセスと、あなたが遭遇するかもしれない特異性についての詳細説明です。 もしあなたが、以下のテキストで何らかの間違いや古い記述を見つけたとき(Linuxディストリビューションはしばしば変化するので)や、記述されていないディストリビューションを使用する場合は、テキストの修正にご協力ください。

ソースファイルの取得

FreeCADをコンパイルする前に、ソースコードを入手します。入手するには３つの方法があります。

Git

ソースコードを入手する一番早く良い方法は、リードオンリーのgitリポジトリを複製することです。(git パッケージをインストールしておく必要があります)

git clone git://free-cad.git.sourceforge.net/gitroot/free-cad/free-cad freecad

上記を実行すると、"freecad"という新しいディレクトリに、最新バージョンFreeCADのソースコードのコピーを置きます。 初めて free-cad.git.sourceforge.netに接続を試みると、sourceforgeのSSH鍵の認証を尋ねるメッセージを受け取ります。 これは、通常、受け入れても安全です。（はっきりしないときは、sourceforge ウェブサイトのSSH鍵をチェックすることができます。）

Gihub

Gihub上のFreeCADレポジトリは、常に最新版です。 github.com/FreeCAD/FreeCAD_sf_master

ソースパッケージ

別の方法として、ソースパッケージのダウンロードもできますが、それらはかなり古い可能性があるので、gitやsubversionで最新版のソースを入手するのが無難です。 ディストリビューションによって、ソースパッケージの入手方法はいくつかあります。

Official FreeCAD source packages (distribution-independent): https://sourceforge.net/projects/free-cad/files/FreeCAD%20Source/
Debian: http://packages.debian.org/source/sid/freecad
Ubuntu: http://packages.ubuntu.com/source/precise/freecad

依存パッケージの取得

LinuxでFreeCADをコンパイルするには、最初にサードパーティライブラリに記載されているすべてのライブラリをインストールする必要があります。 一般的に、最近のディストリビューションでは、いくつかのパッケージをインストールするだけの問題です

Debian and Ubuntu

Debianベースのシステム(Debian, Ubuntu, Mint等)では、必要な全ての依存パッケージをインストールすることは簡単です。 ライブラリのほとんどは、apt-getまたはSynapticパッケージマネージャを介して利用できます。 インストールするために必要な全てのパッケージを、以下に記載します。 あなたが使用しているディストリビューションの最新バージョンを使用しない場合は、以下のパッケージのいくつかは、リポジトリから欠落している可能性があることに注意してください。 その場合、以下の #古くて一般的でないディストリビューション セクションを参照してください。

build-essential
cmake
python
libtool
libcoin60-dev
libsoqt4-dev
libxerces-c-dev
libboost-dev
libboost-filesystem-dev
libboost-regex-dev
libboost-program-options-dev
libboost-signals-dev
libboost-thread-dev
libqt4-dev
libqt4-opengl-dev
qt4-dev-tools
python-dev
こちらか:
     libopencascade-dev (official opencascade version)
または:
     liboce*-dev (opencascade community edition)
     oce-draw
gfortran
libeigen3-dev
libqtwebkit-dev
libode-dev
swig
libzipios++-dev

オプションで、以下の追加パッケージをインストールすることができます。

libsimage-dev (追加のイメージファイルフォーマットをサポートするCoinを作成するために必要)
checkinstall (システムのパッケージマネージャにインストールしたファイルを登録するために必要。あとで簡単にアンインストールできます。)
python-pivy (2D製図モジュールに必要)
python-qt4 (2D製図モジュールに必要)
doxygen and libcoin60-doc (ソースコードのドキュメントを生成する場合)
libspnav-dev (Space NavigatorやSpace Pilot等の3Dconnexion製デバイスのサポート)

Fedora

以下のパッケージが必要です。

cmake
doxygen
swig
gcc-gfortran
gettext
dos2unix
desktop-file-utils
libXmu-devel
freeimage-devel
mesa-libGLU-devel
OCE-devel
python python-devel
boost-devel
tbb-devel
eigen3-devel
qt-devel
qt-webkit-devel
ode-devel
xerces-c
xerces-c-devel
opencv-devel
smesh-devel
coin2-devel
soqt-devel

以下はオプションです。

libspnav-devel (Space NavigatorやSpace Pilot等の3Dconnexion製デバイスのサポート)
pivy ( https://bugzilla.redhat.com/show_bug.cgi?id=458975  Pivyは必須ではありませんが、ドラフトモジュールに必要 )

Fedoraでは公式のレポジトリではcoin2しか提供していないので、coin3でFreeCADをビルドすることはさらに面倒です。 しかし、どうしてもという場合は、 http://www.zultron.com/rpm-repo/ からcoin3-readyのパッケージをインストールすれば、 全てのcoin3/soqt/pivyパッケージを再構築をせずにすみます。

Gentoo

FreeCADのビルドには、以下のパッケージが必要です。

dev-cpp/eigen
dev-games/ode
dev-libs/boost
dev-libs/xerces-c
dev-python/pivy
dev-python/PyQt4
media-libs/coin
media-libs/SoQt
sci-libs/opencascade-6.5
sys-libs/zlib
virtual/fortran
x11-libs/qt-gui
x11-libs/qt-opengl
x11-libs/qt-svg
x11-libs/qt-webkit
x11-libs/qt-xmlpatterns
dev-lang/swig-2.0.4-r1
app-admin/eselect-python-20091230
dev-lang/python-2.7.2-r3
dev-util/cmake-2.8.4
sys-apps/findutils-4.4.0

最新のopencascadeが利用できないので、opencascadeをコンパイルしたくなるかもしれませんが、その場合は以下の追加ライブラリが必要です：

media-libs/ftgl
virtual/opengl
x11-libs/libXmu
dev-lang/tcl-8.5.9
dev-lang/tk-8.5.9-r1
dev-tcltk/itcl-3.4_beta1
dev-tcltk/itk-3.4_pre20090417
dev-tcltk/tix-8.4.3
x11-libs/gl2ps
sys-devel/automake-1.11
sys-devel/autoconf-2.68
sys-devel/libtool
dev-java/java-config-2.1.11-r3

OpenSUSE

以下のパッケージが必要です。

gcc
cmake
OpenCASCADE-devel
libXerces-c-devel
python-devel
libqt4-devel
python-qt4
Coin-devel
SoQt-devel
boost-devel
libode-devel
libQtWebKit-devel
libeigen3-devel
gcc-fortran

FreeCAD 0.13が不安定なので、Eigen3とswigライブラリを追加する必要があります。それらは標準のレポジトリにはありません。それらは以下から１クリックインストールできます。

Eigen3: http://software.opensuse.org/search?q=eigen3&baseproject=openSUSE%3A12.1&lang=en&exclude_debug=true
swig: http://software.opensuse.org/search?q=swig&baseproject=openSUSE%3A12.1&lang=en&exclude_debug=true

Factory EducationのEigen3ライブラリは、しばしば問題を起こしていたので、KDE 4.8 Extraレポジトリのものを使ってください。

古くて一般的でないディストリビューション

他のディストリビューションでは、ユーザーからのフィードバックがほとんど無いので、必要なパッケージを見つけることが難しくなる場合があります。 まず、サードパーティライブラリに記載されている必要なライブラリを用意することを試してください。 そのうちのいくつかはお使いのディストリビューションで若干異なるパッケージ名（name、libname、name-dev、name-devel、等..）になっているかもしれないことに注意してください。

GNU gcc コンパイラ バージョン 3.0.0以上も必要です。 FreeCADは完全にC++で記述されているので、g++も必要です。 コンパイル中には、いくつかのPythonスクリプトも実行されます。 そのため、Pythonインタプリタが正しく機能する必要があります。 ビルドプロセスでのリンカの問題を避けるため、環境変数"LD_LIBRARY_PATH"、もしくは、"ld.so.conf"ファイルに、ライブラリへのパスを追加するのも良いでしょう。 これは、最近のディストリビューションでは一般的なことです。

詳細は、ソースファイル内の"README.Linux"にも書かれています。

以下には、あなたのディストリビューションのリポジトリで見つけることができないかもしれない、いくつかのライブラリについての追加ヘルプです。

Eigen 3

Eigen3ライブラリは現在、Schecherモジュールを必要とします。 このライブラリは、Ubuntu 11.10のリポジトリ以降でのみ使用できます。 前のUbuntuのリリースでは、ここから ダウンロードして手動でインストールするか、インストールする前に以下に示す方法のいずれかを使って、 FreeCAD Daily Builds PPA をソフトウェアのソースに加えてください。

OpenCASCADE　コミュニティ版 (OCE)

OpenCasCade には最近分離した コミュニティ版 があり、これはビルドがはるかに簡単になっています。ご使用のシステムにかかわらず、FreeCADは"公式版"あるいはコミュニティ版のどちらかを利用することができます。OCEのウェブサイトにはビルド手順の詳細があります。

OpenCASCADE 公式版

前文ではOpenCasCadeコミュニティ版はビルドが簡単であると紹介しましたが、公式版も動きます。

全てのLinuxディストリビューションはリポジトリ内に公式版のOpenCasCadeパッケージを持っていません。 もし使えるリポジトリがあるなら、自分自身でリポジトリを確認する必要があります。 少なくともDebian LennyとUbuntu Intrepidには、公式の.debパッケージが用意されています。 古いDebianやUbuntuのリリース用に非公式パッケージをここから入手することができます。あなた自身のプライベートなdebパッケージをビルドするには、次の手順に従います。

wget http://lyre.mit.edu/~powell/opencascade/opencascade_6.2.0.orig.tar.gz
wget http://lyre.mit.edu/~powell/opencascade/opencascade_6.2.0-7.dsc
wget http://lyre.mit.edu/~powell/opencascade/opencascade_6.2.0-7.diff.gz

dpkg-source -x opencascade_6.2.0-7.dsc

# OCC build-deps をインストール
sudo apt-get install build-essential devscripts debhelper autoconf
automake libtool bison libx11-dev tcl8.4-dev tk8.4-dev libgl1-mesa-dev
libglu1-mesa-dev java-gcj-compat-dev libxmu-dev

# Opencascade パッケージのビルド. 数時間以上かかる
# 8GB以上のディスク空き容量
cd opencascade-6.2.0 ; debuild

# 生成されたdebライブラリをインストール
sudo dpkg -i libopencascade6.2-0_6.2.0-7_i386.deb
libopencascade6.2-dev_6.2.0-7_i386.deb

もう一つの方法として、opencascade.orgから最新バージョンをダウンロードしてコンパイルすることもできます。 普通にパッケージをインストールします。インストーラはSun公式のJava ランタイム(パッケージ名：sun-java6-jre)のプログラムであり、UbuntuにバンドルされているオープンソースのJava(gij)でないことに注意してください。 必要に応じてそれをインストールします。

sudo apt-get remove gij
sudo apt-get install sun-java6-jre

あなたがブラウザのプラグイン等の他のものでgijのJavaを使用している場合は注意してください、それらは動かなくなるでしょう。インストーラが動作しない場合は、以下を試してみてください。

java -cp path_to_file_setup.jar <-Dtemp.dir=path_to_tmp_directory> run

パッケージがインストールされたら、opencascade dir内の "ROS"ディレクトリに移動し、以下を実行します。

./configure --with-tcl=/usr/lib/tcl8.4 --with-tk=/usr/lib/tk8.4

ビルドすることができます。 ROSフォルダに戻って操作を行います。:

make

これは長い時間、数時間かかります。

それが終わったら、インストールを実行します。

sudo make install

ライブラリファイルは、/usr/local/lib にコピーされます。このフォルダは他のプログラムが自動的に見つけることができるので、このフォルダにコピーするのが良いです。別の方法としては、以下のようにします。これは"make install"と同じですが、後から簡単にアンインストールできるようにパッケージ管理システムに登録します。

sudo checkinstall

巨大な一時コンパイルファイルを以下のコマンドで今すぐクリーンアップしましょう。

make clean

可能性のあるエラー 1：OCC バージョン 6.2を使っている場合、コンパイラがmakeを実行し始めると同時にに止まります。 もしこの現象が生じたら、"configure"スクリプトで、CXXFLAGS="$CXXFLAGS "の文を見つけて、CXXFLAGS="$CXXFLAGS -ffriend-injection -fpermissive"に修正します。それからconfigureをやり直してください。

可能性のあるエラー 2:：おそらく、幾つかのモジュール(WOKSH, WOKLibs, TKWOKTcl, TKViewerTest and TKDraw)は、tcl/tkのヘッダファイルが見つからないとエラーを出すでしょう。この場合、オプションがconfigureスクリプトに提供されていないので、手動でこれらのモジュールの各々のMakefileを編集する必要があります。：adm/makeや不良モジュールのフォルダに行きます。Makefileを修正して、CSF_TclLibs_INCLUDES = -I/usr/include と CSF_TclTkLibs_INCLUDES = -I/usr/include を設定し、/tck8.4 と /tk8.4を次のように追加します。: SCF_TclLibs_INCLUDES = -I/usr/include/tcl8.4 , SCF_TclTkLibs_INCLUDES = -I/usr/include/tk8.4

SoQt

最新のディストリビューションの場合、SoQtライブラリはQt4に対してコンパイルする必要があります。しかし、この記事の執筆時点で利用可能なSoQt4はDebian用のみであり、すべてのUbuntuにはパッケージがありません。バッケージをビルドするには、次の手順を実行します。:

wget http://ftp.de.debian.org/debian/pool/main/s/soqt/soqt_1.4.1.orig.tar.gz
wget http://ftp.de.debian.org/debian/pool/main/s/soqt/soqt_1.4.1-6.dsc
wget http://ftp.de.debian.org/debian/pool/main/s/soqt/soqt_1.4.1-6.diff.gz
dpkg-source -x soqt_1.4.1-6.dsc
sudo apt-get install doxygen devscripts fakeroot debhelper libqt3-mt-dev qt3-dev-tools libqt4-opengl-dev
cd soqt-1.4.1
debuild
sudo dpkg -i libsoqt4-20_1.4.1-6_i386.deb libsoqt4-dev_1.4.1-6_i386.deb libsoqt-dev-common_1.4.1-6_i386.deb

64bitのシステムの場合、i386の記述をamd64に変えてください。

Pivy

PivyはFreeCADのビルドや実行に必要ないですが、2D製図モジュールを動かすのに必要とされています。 もしこのモジュールを使う予定が無いのであれば、Pivyは必要ありません。執筆時点では、Pivyは非常に新しいものであり、 あなたのお使いのディストリビューションのリポジトリに無い可能性があります。もし、ディストリビューションのパッケージリポジトリにPivyを見つけることができない場合には、FreeCADのダウンロードページから Debian / Ubuntuのパッケージを入手することができます。

http://sourceforge.net/projects/free-cad/files/FreeCAD%20Linux/

または、自分自身でPivyをコンパイルします:

Pivyコンパイル手順

FreeCAD のコンパイル

cMake を使う

CMakeは異なる対象システム（Linux、また、Windows、MacOSX、等）間で共通であるという大きな利点がある新しいビルドシステムです。FreeCADは現在、メインのビルドシステムとしてCMakeを使用しています。CMakeを使用してのコンパイルは、通常は非常に簡単であり、次の2つのステップで実行されます。最初のステップでは、cMakeは、すべての必要なプログラムやライブラリが、お使いのシステム上に存在しているかをチェックし、その後のコンパイルに必要なすべてのことを設定します。以下に詳述するように、いくつか選択する必要がある部分がありますが、FreeCADでは適切な標準値が付与されます。次のステップでは、FreeCADの実行形式を生成するコンパイルです。

FreeCADは大きなアプリケーションなので、コンパイルには少し時間がかかります(速いマシンでは10分、遅いマシンでは30分）。

In-source ビルド

FreeCADは、In-sourceでビルドされます、これはコンパイルで得られた全てのファイルはソースファイルと同じフォルダにあるという意味です。これはFreeCADだけに注目していて、フォルダを削除するだけで簡単に削除できるようにしたいならば良い方法です。しかし、しばしばコンパイルをする場合は、アウトオブソースビルドをおすすめします、これには、より多くの利点があります。以下のコマンドでfreecadをコンパイルします。

cd freecad (freecadのソースのをコピーしたフォルダ)
cmake .
make

あなたのFreeCADの実行形式は "bin" フォルダにあり、それを以下のコマンドで起動できます。

./bin/FreeCAD

Out-of-source ビルド

もしあなたがFreeCADの速い進化について行きたいなら、別のフォルダでビルドするのがずっと便利です。あなたがソースコードをアップデートするたびごとに、cMakeは、どのファイルが変更され、必要なものだけが再コンパイルされるということを賢く区別します。Out-of-sourceのビルドは、Gitシステムを利用していると、あなたはビルドシステムを壊すこと無く、他のブランチを簡単に試すことができるため、特に便利です。out-of-sourceでビルドするには、単純に、あなたのfreecadソースフォルダやbuildディレクトリとは異なるビルドフォルダを作成し、cMakeにソースフォルダを示します。

mkdir freecad-build
cd freecad-build
cmake ../freecad (or whatever the path is to your FreeCAD source folder)
make

FreeCADの実行形式は、"bin"ディレクトリ(freecad-buildディレクトリ内)にあります。

設定オプション

試験的または未完成のモジュールを使いたい場合は、それらをビルドする必要があります。これを行うには、設定段階で適切なオプションをセットする必要があります。コマンドラインで、-D <var>:<type>=<value>オプションをcMakeに渡すか、利用できるGUIフロントエンド（Debianでは、packages cmake-qt-gui や、cmake-curses-gui等）のどれかを使うことで実行できます。

例として、アッセンブリモジュールのビルドをコマンドラインで設定するために、以下を実行します。

cmake -D FREECAD_BUILD_ASSEMBLY:BOOL=ON path-to-freecad-root

利用できるオプションは、FreeCADのルートディレクトリの CmakeLists.txtファイルに書かれています。

autotools を使う

FreeCADはcMakeを推奨しているので、Autotoolsからは離れている途中にありますが、現時点ではまだFreeCADを構築することが可能です。automakeとlibtoolがシステムにインストールされている必要があるため、Debian / Ubuntuでインストールするには以下を実行します。

aptitude install automake libtool

この設定は、gitやsubversionでソースファイルを持っている場合は、configureスクリプト等を作成するために、以下のコマンドを一番最初のステップで実行する必要があります。

./autogen.sh

ビルドプロセスのために、configureスクリプトが提供されています。 ビルドのための全ての設定を行うには、以下を実行します。

./configure

もしあなたが設定した全てのオプションの概要を確認するには、次のように入力します。

./configure --help

通常、あなたのライブラリが本当に珍しいディレクトリにインストールされていない限り、あなたはどのオプションも設定する必要はありません 。設定が完了したら、FreeCADのコンパイルは簡単です。

make

もし何らかのエラーがソースからのビルド中に発生したら、このページとREADME.Linux ファイルをダブルチェクしてください。そしてSourceForgeにある Bug Tracker に行ってください。状態は"Any"とし、過去のコンパイル問題の投稿を見るために"Brouse"ボタンをクリックしてください。FreeCADが正常にビルドされた後は、以下を実行します。

make install

あなたのマシンにFrreeCADをインストールします。デフォルトのインストールディレクトリは以下のとおりです。

~/FreeCAD

あなたのホームフォルダにあるFreeCADフォルダにインストールします。この場合はroot権限は必要ありません。make installの代わりに、以下を実行します。

checkinstall

この方法で、FreeCADはあなたのパッケージマネジメントシステムを使ってインストールされます。そうすると、あとで簡単にアンインストールできます。しかし全てのFreeCADのインストールはシングルディレクトリにインストールされるため、FreeCADディレクトリを削除することも、アンインストールの有効な手段です。

Qt designer プラグイン

もしFreeCADのためのQtの機能を開発したいなら、FreeCADのカスタムウィジェットを提供しているQt Designerプラグインが必要です。以下のディレクトリに移動します。

freecad/src/Tools/plugins/widget

これまで、makefileを提供していませんでした。--しかし以下を実行すれば作られます。

qmake plugin.pro

これを実行した後で以下を実行すると、libFreeCAD_widgets.soライブラリが作成されます。

make

このライブラリをQt Designerに認識させるために、このファイルを $QTDIR/plugin/designer にコピーします。

Doxygen

ソースコードに飛び込むのを大変なことだと感じている場合は、Doxygenが生成するFreeCADの ソースドキュメント を構築し参照することができます。

debian package の作成

もしDebian packageをソースファイルからビルドする場合、まずはじめに以下のパッケージをインストールする必要があります。

dh-make
devscripts
lintian (optional, used for checking if packages are standard-compliant)

パッケージをビルドするにはコンソールを開き、FreeCADのディレクトリに行き、以下を実行します。

debuild

パッケージがビルドされたら、パッケージにエラーが含まれているかどうかをチェックするためにlintian使用することができます。

lintian your-fresh-new-freecad-package.deb (replace by the name of the package you just created)

トラブルシューティング

64bit システムでの注意

64ビット用FreeCADを構築するとき、OpenCASCADE 64ビットパッケージには既知の問題があります。正常に動作するFreeCADを取得するために、あなたは ./configure スクリプトを、追加の定義として"_OCC64"を指定して実行する必要があるかもしれません。

./configure CXXFLAGS="-D_OCC64"

すでにビルドされたOpenCASCADEパッケージを使用している場合は、この定義が組み込まれているので、Debianベースのシステムの場合は、この回避策は必要ありません。上記の説明と同じ方法でFreeCADをコンパイルする必要があります。

Automake マクロ

FreeCADの configureスクリプトは、automakeのマクロ(bnv_have_qt.m4, coin.m4, soqt.m4)を利用していますが、それらはたまにインストールされていないことがあります。もし必要なら(configure時にエラーになった場合）、googleでそれらを探せば、簡単に見つけられるでしょう。それらは簡単なスクリプトで、/usr/share/aclocal フォルダに配置する必要があります。

Fedora 13

Fedora13でコンパイルとインストールをするには、いくつかのヒントやトリックが必要です。

• 必要なパッケージ群をインストールします。ほとんどのはFedora 13のリポジトリから入手可能です。
• xercesのダウンロードおよびビルド
• OpenCascadeをダウンロードしてビルドします。XMUを指すようにする必要があります: ./configure --with-xmu-include=/usr/include/X11/Xmu --with-xmu-library=/usr/lib
• Pivyをダウンロードしてビルドします。 pivy/interfaces/soqt.iから、存在しない"SoQtSpaceball.h"の2つの参照を削除する必要があります。ビルドとインストールが実行できるように、これらの2行をコメントアウトしてください。
• Freecadを設定(configure)します. いくつかの項目を指定する必要があります。: ./configure --with-qt4-include=/usr/include --with-qt4-bin=/usr/lib/qt4/bin --with-occ-lib=/usr/local/lib --with-occ-include=/usr/local/inc --with-xercesc-lib=/usr/local/lib
• makeします。 - soqt の ldflags が "-LNONE" に設定されていて、そのため libtool でエラーが出たためにビルドが中断する問題に直面しました。

この問題を回避するために、/usr/local/Cons2/conf/soqt-default.cfg を修正したら、ldflagsが "-LNONE" でなく "" となりました。これにより、成功しました!

• make install を実行します。

Ubuntu Lucid

Ubuntu Lucidでは、qtwebkit-devはqt4-devに含まれているので、qtwebkit-devは必要ありません。

Automatic ビルドスクリプト

ここでは、FreeCADを完全ビルドに必要なものすべてを紹介します。 1スクリプトでのアプローチでは、ディストリビューションをインストールした直後の状態では動作します。 このコマンドは、rootのパスワード(パッケージのインストールのために)と外部のリポジトリサーバ、もしくはhttpsのsubversionリポジトリのfingerprintを尋ねてきます。 これらのスクリプトは32bitもしくは64bit上で動かすべきです。 それらのスクリプトはバージョンごとに書かれていますが、より新しいバージョンに対しても、 必要ならば、ちょっとした変更をすれば動くと思います。

あなたが好むディストリビューション用のスクリプトを持っていたら、是非送ってください！ 我々はこの記事にそれを組み込みます。

このスクリプトは、 FreeCAD Daily Builds PPA リポジトリに追加されることから始まっていて、 Eigen3ライブラリ(libeigen3-dev)のインストールに進むことができます。もしこのライブラリがすでにインストールされている場合は、スクリプトの最初の行を削除してください。

Ubuntu 10.04 LTS - Lucid Lynx / Ubuntu 10.10 Maverick Meerkat / Ubuntu 11.04 Natty Narwhal

sudo add-apt-repository ppa:freecad-maintainers/freecad-daily && sudo apt-get update
sudo apt-get install build-essential python libcoin60-dev libsoqt4-dev \
libxerces-c2-dev libboost-dev libboost-date-time-dev libboost-filesystem-dev \
libboost-graph-dev libboost-iostreams-dev libboost-program-options-dev \
libboost-serialization-dev libboost-signals-dev libboost-regex-dev libboost-thread-dev \
libqt4-dev qt4-dev-tools python2.7-dev libopencascade-dev libsoqt4-dev \
libode-dev subversion cmake libeigen2-dev libsimage-dev python-qt4 \
libtool autotools-dev automake bison flex gfortran libeigen3-dev libqtwebkit-dev git

# source 最新版のチェックアウト
git clone git://free-cad.git.sourceforge.net/gitroot/free-cad/free-cad freecad

# source ディレクトリに移動
cd freecad

# 設定のビルド
cmake .

# FreeCADのビルド
make

# FreeCADのテスト
cd bin
./FreeCAD -t 0

# FreeCADの実行
./FreeCAD

# 最新版へのアップデート

# source ディレクトリに移動
cd freecad

# sourceをアップデート
git pull

# 設定のビルド
cmake .

# FreeCADのビルド
make

OpenSUSE 12.2

このリリースで FreeCAD 0.13をコンパイルするには、外部リポジトリは必要ありません。 しかしながら、python3-devとの互換性が無く、python3-devを削除する必要があります。 FreeCADはOpenSUSE 12.2と同様に、GITからコンパイルできます。

# 開発に必要なパッケージのインストール
sudo zypper install gcc cmake OpenCASCADE-devel libXerces-c-devel \
python-devel libqt4-devel python-qt4 Coin-devel SoQt-devel boost-devel \
libode-devel libQtWebKit-devel libeigen3-devel gcc-fortran git swig

# 新しいディレクトリの作成と、そのディレクトリへの移動
mkdir FreeCAD-Compiled
cd FreeCAD-Compiled

# sourceの取得
git clone git://free-cad.git.sourceforge.net/gitroot/free-cad/free-cad

# これから free-cad という場所にサブフォルダを持つことになります。そのフォルダはsourceを含んでいます。

# コンパイル用のフォルダを作成して、そこに移動します。
mkdir FreeCAD-Build1
cd FreeCAD-Build1

# 設定のビルド
cmake ../free-cad

# FreeCADのビルド
make

# FreeCADのテスト
cd bin
./FreeCAD -t 0

gitを使っているので、次回コンパイルしたい場合は、全てをクローンする必要はなく、gitから pullして、もう一度コンパイルするだけでよいです。

# 以前に作成したfree-cadディレクトリに移動
cd free-cad

# pull
git pull

# 一つ上のディレクトリに戻る
cd ..

# ここで前から最後のいくつかの手順を繰り返します。

# コンパイル用に他のディレクトリを作成し、そのディレクトリに移動
mkdir FreeCAD-Build2
cd FreeCAD-Build2

# 設定のビルド
cmake ../free-cad

# FreeCADのビルド
make

# FreeCADのテスト
cd bin
./FreeCAD -t 0

OpenSUSE 12.1

FreeCAD 0.13が不安定なので、Eigen3とswigライブラリを追加する必要があります、これは、標準のリポジトリにはないようです。それらは以下から1クリックでインストールできます。

Eigen3: http://software.opensuse.org/search?q=eigen3&baseproject=openSUSE%3A12.1&lang=en&exclude_debug=true

swig: http://software.opensuse.org/search?q=swig&baseproject=openSUSE%3A12.1&lang=en&exclude_debug=true

# 開発に必要なパッケージのインストール
sudo zypper install gcc cmake OpenCASCADE-devel libXerces-c-devel \
python-devel libqt4-devel python-qt4 Coin-devel SoQt-devel boost-devel \
libode-devel libQtWebKit-devel libeigen3-devel gcc-fortran git

# 新しいディレクトリの作成と、そのディレクトリへの移動
mkdir FreeCAD-Compiled
cd FreeCAD-Compiled

# sourceの取得
git clone git://free-cad.git.sourceforge.net/gitroot/free-cad/free-cad

# これから free-cad という場所にサブフォルダを持つことになります。そのフォルダはsourceを含んでいます。

# コンパイル用にディレクトリを作成し、そのディレクトリに移動
mkdir FreeCAD-Build1
cd FreeCAD-Build1

# 設定のビルド
cmake ../free-cad

# FreeCADのビルド
make

# FreeCADのテスト
cd bin
./FreeCAD -t 0

gitを使っているので、次回コンパイルしたい場合は、全てをクローンする必要はなく、gitから pullして、もう一度コンパイルするだけでよいです。

# 以前に作成したfree-cadディレクトリに移動
cd free-cad

# pull
git pull

# 一つ上のディレクトリに戻る
cd ..

# ここで前から最後のいくつかの手順を繰り返します。

# コンパイル用に他のディレクトリを作成し、そのディレクトリに移動
mkdir FreeCAD-Build2
cd FreeCAD-Build2

# 設定のビルド
cmake ../free-cad

# FreeCADのビルド
make

# FreeCADのテスト
cd bin
./FreeCAD -t 0

OpenSuse 11.2

This script is not working at the moment because: このスクリプトは以下の理由により、現在 "動きません"

• libXerces-c-devel が消えているようです…

# 開発に必要なパッケージのインストール
sudo zypper install gcc cmake subversion OpenCASCADE-devel \
libXerces-c-devel python-devel libqt4-devel  python-qt4 \
Coin-devel SoQt-devel boost-devel libode-devel libQtWebKit-devel \
libeigen2-devel gcc-fortran

# sourceの取得
git clone git://free-cad.git.sourceforge.net/gitroot/free-cad/free-cad freecad

# sourceディレクトリに移動
cd freecad

# 設定のビルド
cmake .

# FreeCADのビルド
nice make

# FreeCADのテスト
cd bin
./FreeCAD -t 0

OpenSuse 11.1

# リポジトリの追加 (OpenCascade用)
sudo zypper -p http://packman.unixheads.com/suse/11.1/

# 開発に必要なパッケージのインストール
sudo zypper install gcc cmake subversion OpenCASCADE-devel \
libXerces-c-devel python-devel libqt4-devel  python-qt4 \
Coin-devel SoQt-devel boost-devel libode-devel libQtWebKit-devel \
libeigen2-devel

# sourceの取得
git clone git://free-cad.git.sourceforge.net/gitroot/free-cad/free-cad freecad

# sourceディレクトリに移動
cd freecad

# 設定のビルド
cmake .

# FreeCADのビルド
nice make

# FreeCADのテスト
cd bin
./FreeCAD -t 0

Debian Squeeze

# 必要なツールとライブラリの取得
sudo apt-get install build-essential python libcoin60-dev libsoqt4-dev \
libxerces-c2-dev libboost-dev libboost-date-time-dev libboost-filesystem-dev \
libboost-graph-dev libboost-iostreams-dev libboost-program-options-dev \
libboost-serialization-dev libboost-signals-dev libboost-regex-dev \
libqt4-dev qt4-dev-tools python2.5-dev \
libsimage-dev libopencascade-dev \
libsoqt4-dev libode-dev subversion cmake libeigen2-dev python-pivy \
libtool autotools-dev automake gfortran

# 最新sourceのcheckout
git clone git://free-cad.git.sourceforge.net/gitroot/free-cad/free-cad freecad

# sourceディレクトリに移動
cd freecad

# 設定のビルド
cmake .

# FreeCADのビルド
make

# FreeCADのテスト
cd bin
./FreeCAD -t 0

ソースコードのアップデート

FreeCADの開発は毎日行われ、バグフィックスや新機能が追加されています。cmakeシステムが賢くソースコードのアップデートして、変更部分のみをコンパイルすることができるため、以後のコンパイルがとても高速です。gitやsubversionのソースコードのアップデートはとても簡単です。

cd freecad (もしくはソースコードを最初にクローンした場所)
git pull (gitを使っている場合)

適切なビルド用ディレクトリに移動し、cmakeを再度実行します(FreeCADに関しては、cmakeは、ヘルプメニューのバージョンナンバーのデータをアップデートをするので、）。しかしながら、cmake実行後はソースコードへのパスを設定する必要はなく、空白(スペース)と.(ドット)だけで良いです。

cd ../freecad-build (もしくはビルドディレクトリが置かれている場所)

cmake .

make

Mac OS X は BSD(UNIX)ベースなので、Mac上でのFreeCADのコンパイルはCompileOnUnixと大きく違いませんが、すべての機能を適切に動かすには、Mac特有の重要な点がいくつかあります。 この説明内容は、Lion(10.7)でテストしていますが、(Snow) Leopardが動くIntel Macでも同様に"動くはず"です。

FreeCAD sources のダウンロード

FreeCADのsourceの最新リビジョンをSourceforge subversion リポジトリからチェックアウトします。

svn co http://free-cad.svn.sourceforge.net/svnroot/free-cad/trunk free-cad

依存パッケージのインストール

Mac OS X 10.7上では、以下の依存パッケージがバンドルされていないので、FreeCADのビルドの前にインストールする必要があります。

• sip
• fortran
• xerces-c
• boost
• eigen
• ftgl
• coin3d
• OpenCASCADE
• Qt
• pyqt
• soqt

選択肢 1: Homebrew

"注意" : このセクションは、現在修正中です！フォーラムで最新の投稿を確認してください。

https://forum.freecadweb.org/viewtopic.php?f=4&t=2064&p=15405

Homebrewパッケージマネージャをダウンロードし、インストールします。:

http://mxcl.github.com/homebrew/

FreeCADのほとんどの依存パッケージをコンパイルし、インストールします。:

brew install sip gfortran xerces-c boost eigen coin qt pyqt soqt ftgl

CompileOnMac/jp#OpenCASCADEの構築を確認します。

選択肢 2: MacPorts/Fink

注意：このセクションは更新する必要があります。

(まだMacPortsをインストールしていない場合は) MacPortsをインストールします。 MacPortsは、1つのコマンドで一般的なオープンソースのアプリケーションをダウンロード、コンパイル、インストールできます。UNIX/Linuxの世界では、PKCSRCやAPTに似ているアプリケーションです。インストールするには、MacPortsサイトからディスクイメージをダウンロードして、指示に従ってください。:

http://www.macports.org/install.php

MacPortsをインストールした直後かどうかにかかわらず、MacPortsが最新かどうかを確認したくなるでしょう。以下を実行します。:

sudo port selfupdate

そうすると、MacPortsがインストールされ、最新版になり、FreeCADが必要とするパッケージのインストールをはじめることができます。:

• xercesc
• boost
• py-sip
• ftlg
• f2c
• eigen3
• py-pyqt4

以下のコマンドで、上記のライブラリをコンパイル/インストールできます。もしMacPortsがエラーを出力したら、それらを一つずつ試すことになるでしょう。

sudo port install xercesc boost ftgl f2c eigen3 py-sip py-pyqt4

py-sipやpy-pyqt4のようなpythonパッケージは各MacPortsのPythonのバージョンに対応したパッケージが1つずつあるため、複数のパッケージがあることに注意が必要です。

boostは大きなパッケージです。また、py-pyqt4にはqt4-macが必要でこれも大きなパッケージです。 長いビルドの間に、何が起こっているかを確認するために、port -v instsall を実行したくなるでしょう。

QT4はQtウェブサイトからMac用のバイナリインストーラも利用可能です。 この方法がFreeCADのコンパイルにどのようにうまくいくかは、よくわかりません。

Fortran コンパイラのインストール

FOATRANコンパイラも必要です。Appleで分岐したOSX上のgccはFORTRANが付属していません。

GFortranのコンパイラはここにあり、うまく動作するでしょう:

http://gcc.gnu.org/wiki/GFortranBinaries#MacOS

もしfinkを使っているならば、他の方法としては、次のコマンドを利用することです。(Shaneyfelt 2100.Nov.14)

 sudo fink selfupdate
 sudo fink install gcc46

これは、appleのgccコンパイラコレクションと名前の衝突を避けるために、別のgccコンパイラコレクションをgcc-4という名前でインストールします。

MacPortsのgcc4xパッケージもFORTRANコンパイラを含んでいるので、これでも動作するはずです:

sudo port install gcc46

他の候補となるMacPortsパッケージはg95です。これは有効なFORTRAN90コンパイラと思われ、FreeCADのcmakeコンフィグレーションテストを通るはずですが、実際の構築ではgcc固有のオプションを尋ねられると思われます。そのため、gcc4xを使うのが簡単です。

Eigen3のインストール

最新版のeigen3ライブラリを以下からダウンロードし、解凍します:

http://eigen.tuxfamily.org/index.php?title=Main_Page

これらはソルバー機能のために必要です。解凍すると、'Eigen'という名前のフォルダが以下に作成されます。

/usr/local/include/eigen3/

OpenCASCADEの構築

現在、OS X上でのOpenCASCADEの構築で最も簡単な方法は、コミュニティ版(oce)を使うことです。ソースコードをダウンロードするか、以下のGitレポジトリからチェックアウトしてください:

https://github.com/tpaviot/oce

それから、端末で以下を実行します:

mkdir build
cd build
cmake ..
cd ..
make
make install/strip

FreeCAD.appテンプレートのダウンロードと'インストール'

次のアーカイブはFreeCAD用のアプリケーションバンドルのテンプレートを含んでいます。これは必ずしも必要ではありませんが、デフォルトのインストール構成よりも便利にFreeCADを操作できます。バンドルの推奨インストール場所は/Applicationsフォルダですが、あなたはどこにでもそれを置くことができるはずです - FreeCADがさらに修正されずにコンパイルとインストールされた後では、バンドルが移動できないことを覚えておいてください。次のステップでコンフィグレーションを使用して、make installを実行すると、このバンドルにインストールされます。

http://dl.getdropbox.com/u/103808/FreeCAD/FreeCAD_bundle_template_20091128.tar.gz

コンパイル

FreeCADルートフォルダ内から、以下のコマンドでFreeCADのコンフィグレーション、コンパイル、インストールします。もし、FreeCAD.appバンドルを /Application以外のどこかに置く(もしくはバンドルを使わない)場合は、'PREFIX'引数を適宜変更してください。

./autogen.sh

PREFIX=/Applications/FreeCAD.app/Contents

If you installed dependencies using Option 1 (Homebrew): 選択肢１(Homebrew)を利用して依存関係パッケージをインストールした場合:

注意: このコンフィグレーションコマンドは検証しておらず、エラーを含んでいるかもしれません！

./configure --with-xercesc-lib=/usr/local/lib --with-xercesc-include=/usr/local/include \
--with-boost-lib=/usr/local/lib --with-boost-include=/usr/local/include \
--with-qt4-dir=/usr/local--with-qt4-lib=/usr/local/lib --with-qt4-include=/usr/local/include \
--with-qt4-framework=/usr/local/lib --with-qt4-bin=/usr/local/bin --with-occ-lib=/usr/local/lib \
--with-occ-include=/usr/local/include/oce  --with-coin=/usr/local/lib --with-soqt=/usr/local/lib \
--prefix=/Applications/FreeCAD.app/Contents --bindir=/Applications/FreeCAD.app/Contents/MacOS \
--libdir=/Applications/FreeCAD.app/Contents/Frameworks/FreeCAD \
--includedir=/Applications/FreeCAD.app/Contents/Resources/include \
--datarootdir=/Applications/FreeCAD.app/Contents/Resources/share --enable-debug=no  \
--with-python-include=/System/Library/Frameworks/Python.framework/Versions/2.5/Headers

もしくは、選択肢２(MacPorts/Fink)を利用して依存関係パッケージをインストールした場合:

./configure --with-xercesc-lib=/opt/local/lib --with-xercesc-include=/opt/local/include \
--with-boost-lib=/opt/local/lib --with-boost-include=/opt/local/include \
--with-qt4-dir=/usr/local/Trolltech/Qt-4.8.0 --with-qt4-lib=/usr/local/Trolltech/Qt-4.8.0/lib \
--with-qt4-include=/usr/local/Trolltech/Qt-4.8.0/include --with-qt4-framework=/Library/Frameworks \
--with-qt4-bin=/usr/local/Trolltech/Qt-4.8.0/bin --with-occ-lib=/usr/local/lib \
--with-occ-include=/usr/local/include/oce  --with-coin=/Library/Frameworks \
--with-soqt=/Library/Frameworks --prefix=/Applications/FreeCAD.app/Contents \
--bindir=/Applications/FreeCAD.app/Contents/MacOS --libdir=/Applications/FreeCAD.app/Contents/Frameworks/FreeCAD \
--includedir=/Applications/FreeCAD.app/Contents/Resources/include \
--datarootdir=/Applications/FreeCAD.app/Contents/Resources/share --enable-debug=no  \
--with-python-include=/System/Library/Frameworks/Python.framework/Versions/2.5/Headers

その後、以下を実行します:

make
make install

あなたのマシンの処理能力に応じて、makeのステップにはしばらく時間がかかります。

実行

全てが上手く入ったら、.appバンドルをダブルクリックするとFreeCADが起動するはずです。もし何か問題が生じたら、以下に詳細を投稿してください help forum.

PyQt4

一部のユーザは、FreeCADの起動時に "No Module named PyQt4" というメッセージに直面すると報告しています。以下はそれを修正する回避策です:

cd /Library/Python/2.6/site-packages
sudo ln -s /contrib/lib/python2.6/site-packages/PyQt4 .
sudo ln -s /contrib/lib/python2.6/site-packages/sip* .
cd /volatile/FreeCAD-r5443-ser/bin/pivy
cp _coin.dylib _coin.so
cd /volatile/FreeCAD-r5443-ser/lib
for i in *.dylib; do j=`basename $i .dylib`; cp $i $j.so; done

Pivy

FreeCADのコンポーネントの一部は、Pivyが無いと動きません。 部分的な構築の説明として、ここを見てください。

概要

これらはFreeCADプロジェクト内で変更されていないライブラリです。それらは基本的にはダイナミックリンクライブラリ（*.so または *.dll）としてそのまま使用されています。必要な変更またはラッパークラスが必要なときには、存在する場合、ラッパーのコードまたは変更したライブラリのコードはFreeCADの基本パッケージに移動する必要があります。 使用するライブラリは:

LibPackを使用する代わりに、自分ですべてのものをダウンロードおよびインストールすることを検討してください。

リンク

詳細

Python

バージョン: 2.5 以上

ライセンス: Python 2.5 ライセンス

Pythonについては、http://www.python.org/ のソースコードまたはバイナリを利用する、もしくはhttp://www.activestate.com/ のActiveState Pythonを利用することができますが、ActiveStateからデバッグライブラリを取得するのは少し難しいです。

説明

Pythonは、主要スクリプト言語であり、アプリケーション全体で使用されます。 例えば:

• 以下のテスト用のテストスクリプトの実装:
  • メモリリーク
  • 変更後の機能の存在の確保
  • ビルドチェックの配置
  • 適用テスト
• マクロとマクロの記録
• 標準パッケージのアプリケーションロジックの実装
• ワークベンチ全体のの実装
• パッケージの動的ロード
• 設計ルールの実装(知識工学)
• ワークグループやPDMのような見栄えの良いインターネットの要素
• などなど ...

特にPythonの動的なパッケージの読み込みは、実際の作業に必要なランタイムの追加機能をワークベンチにロードするために使用されます。なぜPythonなのかは、www.python.orgをよく見てください。いくつかの理由があります:これまで私は様々な以下に示すスクリプト言語を使用してきました。:

• Perl
• Tcl/Tk
• VB
• Java

PythonはPerlやTclよりも◯◯で、コードはPerlやVBよりも煩雑ではありません。Javaはそもそもスクリプト言語ではありませんし、組み込むことが困難です(もしくはできません）。Pythonは良くドキュメント化されており、組み込みや拡張が簡単です。Pythonはしっかりテストされており、オープンソースコミュニティの強力なサポートがあります。

賛辞

Guido van Rossum氏と多くの人がPythonの成功をもたらしました!

OpenCasCade

バージョン: 5.2 以上

ライセンス: OCTPL

OCCは、フル機能を備えたCADカーネルです。もともと、それはフランスの Matia Datavision氏がStrim（スタイラー）とユークリッド量子アプリケーション用に開発し、後にオープンソース化されました。それは本当に巨大なライブラリで、オープンソースプロジェクトでは実装が困難、もしくは不可能と思われるいくつかのパッケージを提供されたことで、フリーのCADアプリケーションを可能にした初めてのライブラリです。:

• 完全STEP準拠のジオメトリカーネル
• トポロジデータモデルと、それらを操作ために必要なすべての機能（切り取り、結合、押し出し、などなど...）
• STEP、IGES、VRML等の標準インポート/エクスポートプロセッサ
• 選択をサポートしている3Dと2Dのビューア
• ドキュメントの外部リンクの保存と復元、設計履歴（パラメトリックモデリング）の再計算をサポートしたドキュメントやプロジェクトデータ構造と、拡張パッケージとして動的に新しいデータ型をロードする機能

OpenCasCadeの詳細は、OpenCasCadeページまたはhttp://www.opencascade.orgを見てください。

Qt

バージョン: 4.1.x 以上

ライセンス: GPL v2.0/v3.0 もしくは 商用 (バージョン 4.5からはLGPL v2.1)

Qtのについて多くのことを伝える必要がないと思います。それは、オープンソースプロジェクトの中で最も頻繁に使用されるGUIツールキットの一つです。Qtを使用する最も重要な理由は、Qt Designerと全体のダイアログボックスを（XML）リソースとしてロードし、特殊なウィジェットを組み込む実現性です。CAXのアプリケーションでは、ユーザーとの対話やダイアログボックスがコードの大部分を占めていて、新しい機能を持つFreeCADを簡単に拡張するために、優れたダイアログデザイナーがとても重要です。さらに詳しい情報や、とても良いオンラインドキュメントは、http://www.qtsoftware.comで見つけることができます。

Coin3D

バージョン: 2.0 以上

ライセンス: GPL v2.0 もしくは商用

Coinは、C + +アプリケーションプログラミングインターフェースを備えた高レベル3Dグラフィックスライブラリです。Coinは、科学的·工学的な視覚化アプリケーションのほとんどすべての種類に適したリアルタイムグラフィックスをレンダリングするためにシーングラフデータ構造を使用しています。

Coinは、さまざまなプラットフォーム：任意のUNIX / Linux/ * BSDのプラットフォーム、すべてのMicrosoft Windowsオペレーティングシステム、およびMac OS Xに移植可能です

Coinは業界標準の瞬時レンダリングライブラリOpenGL上に構築されており、高い水準のプリミティブの抽象化が追加されており、3Dインタラクティビティを提供し、プログラマの利便性と生産性を向上し、アプリケーションプログラマに対して手間がかかっている多くの高速描画用の最適化機能をわかりやすく提供しています。

CoinはSGI Open InventorのAPIに基づいています。それに精通していない人にとって、Open Inventorは科学的·工学的コミュニティにおける3Dビジュアライゼーションとビジュアルシミュレーションソフトウェアのデファクトスタンダードのグラフィックスライブラリになって久しいです。Coinは世界中の大規模なエンジニアリングアプリケーションの数千の主要なビルディングブロックとして貢献していることから、その成熟度は10年以上の期間にわたって価値が証明されました。

OpenCasCadeビューワ（AISおよびGraphics3D）は、大規模なエンジニアリングレンダリングに大きな限界と性能のボトルネックがあるので、我々はFreeCADでは3DビューワとしてOpenInventorを使用します。テクスチャやボリュームレンダリングなどは、まだサポートされていません。

バージョン2.0のCoinは、異なるライセンスモデルを採用しているため。それはもはやLGPLではありません。彼らはオープンソースに対してGPLを、クローズドソースに対して商用ライセンスを使用しています。このことは、あなたがFreeCADに基づいた製品（拡張モジュール）を販売する場合は、Coinのライセンスを購入する必要があるということです！

ODE (Open dynamic engine)

バージョン: 0.10.0 or higher

ライセンス: LGPL v2.1以降 または BSD

ODEは剛体力学をシミュレートするためのオープンソースの高性能なライブラリです。ODEは十分な機能があり、安定で成熟しており、プラットフォーム非依存で、C/C++ APIを簡単に使えます。ODEは先進的なジョイント型と統合した摩擦を含む衝突検出があります。 ODEは車両や仮想現実環境内のオブジェクト、仮想生物のシミュレートに有用です。それは現在、多くのコンピュータゲーム、3Dオーサリングツールとシミュレーションツールで使用されています。

謝辞

ラッセル·スミス氏は、ODEの主著者です。

SoQt

バージョン: 1.2.0 以上

ライセンス: GPL v2.0 または 商用

SoQtはQt GUIツールキットを繋ぐ発明です。残念ながら、それはLGPLではないので、私たちはFreeCADの基本コードから取り外し、ライブラリとしてリンクする必要があります。それはCoinのような同様のライセンスモデルを採用しています。そして、あなたは、Qtのバージョンを使用してコンパイルする必要があります。

Xerces-C++

バージョン: 2.7.0 以上

ライセンス Apache Software License Version 2.0

Xerces-C++は、C++の移植可能なサブセットとして書かれた検証用XMLパーサです。Xerces-C++を使うと、あなたのアプリケーションにXMLの読み書き機能を追加することが簡単になります。共有ライブラリは、XML文書を解析、生成、操作、検証するために提供されています。

Xerces-C++はXML 1.0の提案と、多くの関連規格（以下を参照）に忠実です。

パーサは高性能、モジュール性、スケーラビリティを提供します。ソースコード、サンプル、APIドキュメントは、パーサとともに提供されます。移植性のために、テンプレートの利用の最小化、RTTIの不使用、#ifdefsの利用を最小化するように配慮されています。

パーサはFreeCADの中のパラメータを保存および復元するために使用されます。

GTS

バージョン: 0.7.x

ライセンス: LGPL v2.0 以降

GTSは、GNU Triangulated Surface Libraryの略です。これは、三角形の結合で構成される３次元の面を取り扱うために便利な機能のセットを提供することを目的としたオープンソースフリーソフトウェアライブラリです。ソースコードはフリーソフトウェアLGPLライセンスの下で無料で利用可能です。

実際のところ、FreeCADのをコンパイルするのに必要ではありません。あなたはFCConfig.hの中でproprocessorスイッチで使用するかどうかの切り替えができます。

Zlib

バージョン: 1.x.x

ライセンス: zlib License zlibは自由で、汎用で、合法的に邪魔されない--これは、どの特許も侵害していない-- 実質的にどんなハードウェアやOSでも利用できるロスレスのデータ圧縮ライブラリです。 zlibのデータフォーマットはプラットフォーム間で互換性があります。　Unixのcompress(1)やGIFイメージフォーマット等のLZW圧縮法とは異なり、zlibで使用されている圧縮方法は、基本的にデータを膨らますことはありません。(LZWはひどい場合は２倍や３倍のファイルサイズになります。）zlibのメモリ使用量は、入力データとは独立しており、圧縮時に必要に応じて減らすことができます。

Boost

バージョン: 1.33.x

ライセンス: Boost Software License - Version 1.0

Boost C++ライブラリは、同業者の評論の対象になるような、C++の機能を拡張したオープンソースのライブラリの機能の集まりです。ライブラリは、Boostがオープンとクローズ両方のソースのプロジェクトで使用できるように、Boost Software Licenseの下でライセンスされています。Boostの創設者の多くは、C + +の標準化委員会の上にいて、いくつかのBoostライブラリは、C++0xの技術研究報告1に組み込むために受理されています。

ライブラリは、C++ユーザとアプリケーションドメインの広い範囲を対象としています。それらはSmartPtrような汎用ライブラリから、ファイルシステムのようなOSの抽象化、主に、MPLのような他のライブラリの開発と高度なC++ユーザーを目的としたライブラリを範囲としています。

効率性と柔軟性を確保するために、Boostはテンプレートを多用します。 BoostはC++言語でのジェネリックプログラミングやメタプログラミングに広範な仕事や研究の源となっています。

http://www.boost.org/ for details. を見てください。

LibPack

LibPackは上記のすべてのライブラリを一緒に梱包した便利なパッケージです。現在、Windowsプラットフォームではダウンロードページから利用可能です！あなたがLinuxで作業していれば、LibPackを必要としません。代わりにお使いのLinuxディストリビューションのパッケージリポジトリを利用するべきです。

FreeCADLibs7.x Changelog

• QT 4.5.x と Coin 3.1.x を使用
• Robot追加のためのEigenテンプレート
• 実験的なSMESH

トップページ

すべての厳格なソフトウェア開発のためには、ツールが必要です。以下は、FreeCADの開発に使用するツールのリストです。

プラットフォーム非依存のツール

Qt-Toolkit

Qtツールキットは、芸術、プラットフォーム非依存のユーザーインターフェイスデザインツールです。それはLibPackのFreeCADの中に含まれていますが、www.trolltech.comでもダウンロードすることができます。

InkScape

偉大なベクトル描画のプログラムです。 SVG標準のAdhersは、アイコンと画像を描画するために使用されています。 www.inkscape.orgでそれを入手してください。

Doxygen

cppファイルと.hからソースドキュメントとを生成するために、非常に良好で、安定したツールです。

The Gimp

GNU画像処理プログラムについて言うことはあまりありません。さらに、QTのプログラムでアイコンを取り扱うのに便利な.xpmファイルを扱うことができます。 基本的に、XPMはプログラムにコンパイルすることができるCのコードです。

ここからGIMPを取得できます: www.gimp.org

Windowsのツール

Visual Studio 8 Express

VC8はVisualStudio6(IMOの大きなステップバック)から、一歩も前進していないC++開発環境ですが、Windows上で無料の開発ツールです。ネイティブのWin32アプリケーションのために、PlatformSDKをMSからダウンロードする必要があります。

なので、エクスプレス版は、見つけるのは難しいです。しかし、[1]を試してみてください

CamStudio

CAMSourceはスクリーンキャストを（Webキャスト）を記録するためのオープンソースのツールです。それらを記録することによって、チュートリアルを作成するその非常に優れたツールです。ドキュメントを書くことに退屈しません。

詳細は[camstudio.org http://camstudio.org/]を見てください

Tortoise SVN

これは非常に優れたツールです。これはSubversion（sf.net上の私たちのバージョン管理システム）を使用して、本当に喜んでいます。あなたはエクスプローラの集積化を行うことができ、簡単にリビジョンを管理し、diffで確認し、衝突を解決して、ブランチを作るなど…ができます。コミットダイアログ自体が芸術作品です。それはあなたの変更されたファイルの概要を与え、あなたがコミットまたはしないでそれらを置くことができます。それは簡単に論理ユニットへの変更をバンドルし、それらに明確なコミットメッセージを与えることになります。

あなたはtortoisesvn.tigris.orgでToroiseSVNを見つけることができます。

StarUML

フル機能を備えたオープンソースUMLのプログラムです。それは C + +のソースコードのリバースエンジニアリングを含む大きな機能をたくさん持っています…

Downloadはこちらから: staruml.sourceforge.net

Linuxのツール

TODO

このページには、FreeCADの最も重要な設定機能を起動するためのさまざまな方法を示しています。

コマンドラインからFreeCADを起動

FreeCADは、そのデスクトップアイコンをダブルクリックするか、スタートメニューから選ぶことで起動することができますが、コマンドラインから直接起動することもできます。そうすることで、デフォルトの起動オプションを変更することができます。

コマンドラインオプション

コマンドラインオプションは、頻繁に変更の対象となっています。そのため、次のように入力して、現在のオプションを確認することをお勧めします：

FreeCAD --help

コマンドの出力から、使用可能なパラメータを確認できます：

使用方法:
FreeCAD [options] File1 File2 .....
Allowed options:  

Generic options:
 -v [ --version ]      print version string
 -h [ --help ]         print help message
 -c [ --console ]      start in console mode

Configuration:
 -l [ --write-log ] arg    write a log file
 -t [ --run-test ] arg     test level
 -M [ --module-path ] arg  additional module paths
 -P [ --python-path ] arg  additional python paths
 --response-file arg       can be specified with '@name', too

responseとconfigファイル

FreeCADは、configファイルからこれらのオプションのいくつかを読み込むことができます。このファイルには、binのパスに配置し、FreeCAD.cfgという名前を付ける必要があります。コマンドラインで指定したオプションは、設定ファイルの設定よりも優先されることに注意してください！

一部のオペレーティング·システムでは、コマンドラインの長さが非常に短いという制限があります。これらの制限を回避する一般的な方法は、応答ファイルを使用することです。応答ファイルには、単にコマンドラインと同じ構文を使用するconfigファイルです。コマンドラインで使用するresponseファイルの名前を指定した場合は、コマンドラインに加えて、このファイルがロードされ、解釈されます：

FreeCAD @ResponseFile.txt 

もしくは:

FreeCAD --response-file=ResponseFile.txt

隠しオプション

ユーザには開示していないオプションがいくつかあります。これらのオプションは、例えばWindowsシステムで解釈されるX-Windowパラメータです。：

• -display display, Xディスプレイのセット (デフォルトは $DISPLAY).
• -geometry geometry, 表示している最初のウィンドウのクライアントの形状 .
• -fn または -font font, アプリケーションフォントの定義。それらのフォントはXlogical font descriptionを使って特定されます。
• -bg または -background color, デフォルトのバックグラウンドの色と、アプリケーションパレット(光と影が計算される).
• -fg または -foreground color, デフォルトのフォアグラウンドカラーの設定
• -btn または -button color, デフォルトのボタン色の設定
• -name name, アプリケーション名の設定
• -title title, アプリケーションタイトルの設定
• -visual TrueColor, 8-bitディスプレイでTrueColor画面をアプリケーションを強制的に使わせる。
• -ncols count, アプリケーションはQApplication:: ManyColor色指定を使用している場合は、8ビットのディスプレイ上の色のキューブに割り当てられた色の数を制限します。カウントが216である場合、6x6x6カラーキューブ（つまり6つの赤、緑、青のレベル）に使用され、その他の値については、2x3x1キューブにほぼ比例したキューブが使用されます。
• -cmap, 8ビットディスプレイ上のプライベートカラーマップをアプリケーションにインストールして適用する。

ユーザーインターフェイスを持たないFreeCADを稼働

FreeCADは通常、GUIモードで起動しますが、コマンドラインから

FreeCAD -c

を入力して、コンソールモードで起動することもできます。コンソールモードでは、ユーザーインターフェイスが表示されません、そして、Pythonインタプリタのプロンプトが表示されます。そのpythonのプロンプトから、FreeCADGuiモジュールを除くFreeCADのすべてのモジュールやプラグインにアクセスでき、FreeCAD内部で実行されるPythonインタプリタと同様の機能を使用できます。 FreeCADGuiに依存するモジュールについても使用できない場合がありますので注意してください。

PythonモジュールとしてFreeCADを実行

FreeCADはPythonを使う他のアプリケーションの内部、または、外部のPython shellから、Pythonモジュールとして利用することができます。このため、主となるPythonアプリケーションにFreeCADのLIBSがある場所を知らせる必要があります。その最善の方法は、一時的にsys.path変数にFreeCADのlibパスを追加することです。以下に示すコードを任意のpythonシェルで入力すると、FreeCADをインポートし、FreeCADをコンソールモードと同じ方法で実行できるようになります。

import sys sys.path.append("path/to/FreeCAD/lib") # FreeCADのlibパスにしたがって変更してください import FreeCAD

一度FreeCADをロードすれば、あなたが想像できるいかなる方法を用いて、ホストアプリケーションと情報をやり取りできるようにするのは、あなた次第です！

設定のセット

毎回のFreeCADの立ち上げ時に、その環境とコマンドラインパラメータを調べます。これは、実行時の情報の本質を保持している '構成設定'を構築します。この情報は、後でユーザーデータファイルまたはログファイルを保存する場所を決定するために使用されます。それは、異常終了を分析するためにもとても重要です。そのため、それはログファイルに保存されます。

ユーザ関連情報

コマンドライン引数

システム関連

いくつかのライブラリは、システム環境変数を呼び出す必要があります。時々、FreeCADのインストールに問題があることがありますが、いくつかの環境変数が存在しないか、または誤って設定されていることが原因です。そのため、いくつかの重要な変数は、Configに複製され、ログファイルに保存されます。

Python に関連した環境変数:

• PYTHONPATH
• PYTHONHOME
• TCL_LIBRARY
• TCLLIBPATH

OpenCascade に関連した環境変数:

• CSF_MDTVFontDirectory
• CSF_MDTVTexturesDirectory
• CSF_UnitsDefinition
• CSF_UnitsLexicon
• CSF_StandardDefaults
• CSF_PluginDefaults
• CSF_LANGUAGE
• CSF_SHMessage
• CSF_XCAFDefaults
• CSF_GraphicShr
• CSF_IGESDefaults
• CSF_STEPDefaults

システムに関連した環境変数:

• PATH

ビルドに関連した情報

下記の表は、ビルドバージョンに関する利用可能な情報を示しています。それのほとんどは、Subversionリポジトリからのものです。以下のものは、正確にバージョンを再構築するために必要です！

ブランド関連

これらの構成エントリはFreeCADのブランディング機構に関連しています。詳細はブランディングを参照してください。

FreeCAD build tool または fcbt は、以下の場所にあるpythonスクリプトです。

trunc/src/Tools/fcbt.py

このスクリプトは、FreeCADのビルド時、配布時、拡張時の煩雑なタスクを単純化するのに使われます。

使用方法

Pythonを正常にインストールすると、"fcbt"を以下のコマンドで呼び出すことができます。

python fbct.py

あなたが使いたいタスクのメニューを表示します。:

FreeCAD Build Tool
 Usage:
    fcbt <command name> [command parameter]
 possible commands are:
  - DistSrc         (DS)   Build a source Distr. of the current source tree
  - DistBin         (DB)   Build a binary Distr. of the current source tree
  - DistSetup       (DI)   Build a Setup Distr. of the current source tree
  - DistSetup       (DUI)  Build a User Setup Distr. of the current source tree
  - DistAll         (DA)   Run all three above modules
  - NextBuildNumber (NBN)  Increase the Build Number of this Version
  - CreateModule    (CM)   Insert a new FreeCAD Module in the module directory

 For help on the modules type:
   fcbt <command name> ?

プロンプト入力時に、呼び出すコマンドの省略形を入力します。例えば、 モジュール作成は、"CM"を入力します。

DistSrc

"DS"コマンドは、現在のソースツリーの ソース配布パッケージを作成します 。

DistBin

"DB"コマンドは、 現在のソースツリーの バイナリ配布パッケージを作成します 。

DistSetup

"DI"コマンドは、 現在のソースツリーの セットアップ配布パッケージを作成します 。

DistSetup

"DUI"コマンドは、 現在のソースツリーの ユーザセットアップ配布パッケージを作成します 。

DistAll

"DA"コマンドは、 "DS", "DB" と "DI" を順番に実行します。

NextBuildNumber

"NBN" コマンドは、 新しいバージョンのFreeCADを作成するために、 ビルドナンバーを増やします 。

CreateModule

"CM"コマンドは 新しいアプリケーションモジュールを作成します。

FreeCADでの新しいモジュールとワークベンチの追加はとても簡単です。ここで言うモジュールとはFreeCADの任意の拡張機能のことで、ワークベンチとはいくつかのツールバーとメニューをまとめた特別なGUI設定のことです。通常は独自のワークベンチを備えた新しいモジュールを作ります。

モジュールはC++またはPythonまたはそれらを混ぜたものでプログラムされます。ただしモジュールの初期化ファイルは必ずPythonでなければなりません。初期化ファイルでの新しいモジュールの設定は簡単で、手作業でも行えますしFreeCADのビルドツールでも行えます。

FreeCADビルドツール

FreeCADでの新しいアプリケーションモジュールの作成は非常に単純です。FreeCADの開発ツリーの中にはFreeCADビルドツール (fcbt)が存在し、これがあなたにとって最も重要なものになります。

trunk/src/Tools/fcbt.py

の下にあるPythonスクリプトがそれです。Pythonインタプリタが正しくインストールされていればこのスクリプトを次のコマンドラインで実行できます。

python fcbt.py

すると次の様なメニューが表示されます：

FreeCAD Build Tool
Usage:
   fcbt <command name> [command parameter] 
possible commands are:
 - DistSrc         (DS)   Build a source Distr. of the current source tree
 - DistBin         (DB)   Build a binary Distr. of the current source tree
 - DistSetup       (DI)   Build a Setup Distr. of the current source tree
 - DistSetup       (DUI)  Build a User Setup Distr. of the current source tree
 - DistAll         (DA)   Run all three above modules
 - BuildDoc        (BD)   Create the documentation (source docs)
 - NextBuildNumber (NBN)  Increase the Build Number of this Version
 - CreateModule    (CM)   Insert a new FreeCAD Module in the module directory

For help on the modules type:
  fcbt <command name> ?

コマンドプロンプトにCMと入力するとモジュールの作成が開始します：

Insert command: CM

次にあなたの新しいモジュールの名前を指定するように促されます：

Please enter a name for your application: TestMod

エンターを押すとfcbtはあなたのモジュールが必要とする全てのファイルを次の新しいフォルダにコピーします：

trunk/src/Mod/TestMod/

次にファイル全てに対してあなたの新しいモジュールの名前での変更が行われます。それが終われば後はあなたのワークスペース（Windows）またはmakefileのターゲット（UNIX）に"appTestMod"と"appTestModGui"の二つの新しいプロジェクトを追加するだけです。これで終わりです！

新しいモジュールを手作業で設定する

新しいモジュールを作るためには二つの作業が必要です：

• FreeCADのModフォルダ（インストールパス/FreeCAD/Modまたはユーザーパス/.FreeCAD/Modのどちらか）に新しいフォルダを作成。名前は好きなものを使用できます。
• そのフォルダの中にInitGui.pyファイルを置きます。このファイルはFreeCAD起動時に自動で実行されます（例えば中にprint("hello world")と書いてみてください）。

さらにInit.pyファイルを置くこともできます。InitGui.pyファイルがFreeCADをGUIモードで実行した時にしか読み込まれないのに対してInit.pyファイルは常に読み込まれます。ただしワークベンチを作成しようとする場合にはInitGui.pyを置きましょう。言うまでもなくワークベンチはGUIでしか使用されないからです。

新しいワークベンチの作成

InitGui.pyファイルの中でまず行いたいのはワークベンチを定義することです。以下にあなたが使うことのできる最小のコードを記載しておきます：

class MyWorkbench ( Workbench ):
"My workbench object"
Icon = """
/* XPM */
static const char *test_icon[]={
"16 16 2 1",
"a c #000000",
". c None",
"................",
"................",
"..############..",
"..############..",
"..############..",
"......####......",
"......####......",
"......####......",
"......####......",
"......####......",
"......####......",
"......####......",
"......####......",
"......####......",
"................",
"................"};
"""
MenuText = "My Workbench"
ToolTip = "This is my extraordinary workbench"

        def GetClassName(self):
               return "Gui::PythonWorkbench"

def Initialize(self):
import myModule1, myModule2
self.appendToolbar("My Tools", ["MyCommand1","MyCommand2"])
self.appendMenu("My Tools", ["MyCommand1","MyCommand2"])
Log ("Loading MyModule... done\n")

def Activated(self):
               # 必要な場合はここで処理を行う...
Msg ("MyWorkbench.Activated()\n")

def Deactivated(self):
               # 必要な場合はここで処理を行う...
Msg ("MyWorkbench.Deactivated()\n")

FreeCADGui.addWorkbench(MyWorkbench)

ワークベンチには次の属性が全て定義されている必要があります：

• Icon。XPM画像です（GIMPを始めとしたほとんどのソフトウェアで画像をテキストファイルであるXPM形式に変換できます。変換した内容をここにペーストしてください）。
• MenuText。ワークベンチリストに表示されるワークベンチ名です。
• Tooltip。マウスオーバーした際に表示されます。
• Initialize()。FreeCAD起動の際に実行され、ここでワークベンチが使用する全てのメニューとツールバーが作成されなければなりません。モジュールをC++で作成する場合はこのInitGui.pyファイルの中ではなくC++モジュールの中でメニューとツールバーを定義することもできます。大事なのはモジュールがアクティブ化された時ではなく、今、メニューとツールバーを作成することなのです。
• Activated()。ユーザーがあなたのワークベンチに切り替えた際に実行されます。
• Deactivated()。ユーザーがあなたのワークベンチから他のワークベンチに切り替えるか、FreeCADを終了した際に実行されます。

PythonでのFreeCADコマンドの作成

通常、自作ツール（FreeCADではコマンドと呼ばれます）は全て他のモジュールに定義してツールバーやメニューが作成される前にそのモジュールをインポートするようにします。以下にあなたがコマンドの定義で使うことのできる最小のコードを記載しておきます：

import FreeCAD,FreeCADGui

class MyTool:
"My tool object"

       def GetResources(self):
               return {"MenuText": "My Command",
                       "Accel": "Ctrl+M",
                       "ToolTip": "My extraordinary command",
                       "Pixmap"  : """
/* XPM */
static const char *test_icon[]={
"16 16 2 1",
"a c #000000",
". c None",
"................",
"................",
"..############..",
"..############..",
"..############..",
"......####......",
"......####......",
"......####......",
"......####......",
"......####......",
"......####......",
"......####......",
"......####......",
"......####......",
"................",
"................"};
"""}

       def IsActive(self):
               if FreeCAD.ActiveDocument == None:
                       return False
               else:
                       return True

def Activated(self):
               # ここで何か処理する...

FreeCADGui.addCommand('MyCommand1',MyTool())

• GetResources()メソッドはツールの視覚属性が入った辞書を返さなければなりません。Accelでショートカットキーが定義されますがこれは必須ではありません。
• IsActive()メソッドはメニューやツールバー内でコマンドがアクティブか、グレーアウトしているかを定義します。
• Activated()メソッドはツールバーボタン、メニューまたはスクリプトによってコマンドが呼ばれた際に実行されます。

C++でのFreeCADコマンドの作成

ドキュメント作成予定

まずテストしてください

テストフレームワークを使用してデバッグの面倒から解放される前に標準テストが正しく動作するかを調べてください。もし動作しなければ恐らくインストールが正しく行われていません。

コマンドライン

FreeCADのデバッグはいくつかの内部メカニズムによってサポートされています。コマンドライン版のFreeCADでは以下のデバッグサポート用オプションが使えます：

-v

"v"オプションを使うとFreeCADはより詳細な出力を行う様になります。

-l

"l"オプションを使うとFreeCADはログファイルに追加情報を書き込む様になります。

イントロダクション

FreeCADには豊富なテストフレームワークが付属しています。これらのテスト環境はテストモジュール内に置かれた複数のPythonスクリプトを基盤としてます。

この記事ではFreeCADのブランディングについて説明しています。ブランディングとはFreeCADをベースとしてあなた独自のアプリケーションを作成することを意味します。あなただけの実行ファイルやスプラッシュスクリーンを作ることもできますし、完全に作り直したプログラムの作成さえ可能です。FreeCADは柔軟なアーキテクチャをしており、特定の目的のためのあなたのプログラムの基盤として簡単に使用することができます。

概要

ブランディングのほとんどはMainCmd.cppまたはMainGui.cppで行われます。これらのプロジェクトはFreeCADの実行ファイルを生成します。あなた独自のブランドを作るにはMainプロジェクトまたはMainGuiプロジェクトをコピーしてFooApp.exeといった独自の名前の実行ファイルにするだけです。 新しい外観のための最も重要な設定はmain()関数内で行うことができます。以下にブランディング制御のためのコードを記載しておきます：

int main( int argc, char ** argv )
{
  // Name and Version of the Application
  App::Application::Config()["ExeName"] = "FooApp.exe";
  App::Application::Config()["ExeVersion"] = "0.7";

  // set the banner (for loging and console)
  App::Application::Config()["ConsoleBanner"] = sBanner;
  App::Application::Config()["AppIcon"] = "FCIcon";
  App::Application::Config()["SplashPicture"] = "FooAppSplasher";
  App::Application::Config()["StartWorkbench"] = "Part design";
  App::Application::Config()["HiddenDockWindow"] = "Property editor";
  App::Application::Config()["SplashAlignment" ] = "Bottom|Left";
  App::Application::Config()["SplashTextColor" ] = "#000000"; // black

  // Inits the Application 
  App::Application::Config()["RunMode"] = "Gui";
  App::Application::init(argc,argv);

  Gui::BitmapFactory().addXPM("FooAppSplasher", ( const char** ) splash_screen);

  Gui::Application::initApplication();
  Gui::Application::runApplication();
  App::Application::destruct();

  return 0;
}

最初のConfigでプログラムの名前を定義しています。これはコンパイラ設定やリネームによって変更できる実行ファイルの名前ではなく、Windowsでのタスクバーや、Unix系でのプログラムリストに表示される名前です。

次の行ではFooAppアプリケーションの設定を定義しています。Configの記述方法と内容については起動と設定.を見てください。

画像

全ての画像リソースはコンパイルでFreeCADに組み込まれます。これによって読み込み時の遅延時間が減り、インストールもコンパクトになるのです。画像はCの構文を使用した基本的にはテキスト形式のXPM形式でインクルードされます。原理的にはこの画像をテキストエディタで描くことも可能ですが、実際はあなたの好きな画像編集プログラムを使って画像を作成し後でXPM形式に変換したほうが楽でしょう。

GNUの画像編集プログラムであるGimpではXPMファイルの保存が可能です。

変換にはFreeCADに付属しているImageConvツールを使うことができます。このツールは以下にあります。

/trunk/src/Tools/ImageTools/ImageConv

これを使えば画像を変換するだけではなく画像が登録されるBmpFactoryIcons.cppファイルを自動で更新することもできます。典型的な使用方法は以下の例のようなシンプルなものです：

ImageConv -i InputImage.png -o OutputImage.xpm

この例ではファイルInputImage.pngをXPM形式に変換し、その結果をファイルOutputImage.xpmに書き込んでいます。

main()内の

Gui::BitmapFactory().addXPM("FooAppSplasher", ( const char** ) splash_screen);

の行でFreeCADのBitmapFactory内の画像をインクルードしています。

アイコン

ウィンドウタイトルなどに表示されるメインアプリケーションアイコンFCIconは

/trunk/src/Gui/Icons/images.cpp

内の以下の行以降で定義されています。

static const char *FCIcon[]={

これをあなたの好みのアイコンと置き換え、FreeCADを再コンパイルすればあなた独自のブランド作成のための手順は終わりです。このファイルの中には他にもたくさんのアイコンがあり、あなたの好みに応じて変更可能です。

新しいアイコンを追加する必要がある場合は

/trunk/src/Gui/Icons/BmpFactoryIcons.cpp

の中に定義してください、そうすればFreeCADからのアクセスが可能になります。

背景画像

ドキュメントがないウィンドウが開かれた際には背景画像が表示されます。スプラッシュ画面と同様、これはdevelopers.h内の以下から始まる部分で定義されています：

static const char* const background[]={

背景には低コントラストな画像を選ぶべきです。さもないとユーザーを苛立たせてしまうでしょう。

ローカライゼーションとは、複数の言語のユーザーインタフェースをソフトウェアに与える一般的なプロセスです。FreeCADでは、編集→設定→アプリケーションを編集するで、ユーザーインターフェイスの言語を設定することができます。FreeCADは、Qtを使用して複数の言語のサポートを可能にしています。Unix / Linuxシステム上では、FreeCADはシステムの現在の地域設定を使用するよう初期設定されています。

FreeCAD翻訳の支援

プログラマ以外の人々がFreeCADのためにできる最も重要な事の一つが、プログラムの翻訳を助けることです。オンライン共同翻訳システムCrowdinの採用により、翻訳作業は以前よりとても簡単になりました。

翻訳のやり方

• Crowdin上のFreeCAD翻訳プロジェクト・ページへ行ってください
• 新しいプロファイルを作成するか、Gmailのアドレスのようなサードパーティのアカウントを使用してログインしてください
• 作業したい言語をクリックしてください
• ファイルを選択し、ファイルの横にある「翻訳開始ボタン」をクリックします。例えば、FreeCAD.tsはFreeCADのメインGUIのテキスト文字列を持ちます
• 既存の翻訳へ投票や、独自の訳を作成することができます。

注 ：あなたがFreeCADの翻訳に活発に参加しており、次のリリースの開始準備を事前に知って翻訳のレビューを行いたい場合には、以下に登録してください。 http://www.freecadweb.org/tracker/view.php?id=137

Qt-Linguistによる翻訳（昔の方法）

以下の情報は今後使用される必要がなく、おそらく廃れていくでしょう。この情報は、プログラマがその動作をよく理解する手助けになる可能性があるため残されています。

• 以下に示すFreeCADのすべての言語フォルダを開きます。
• あなたの言語コードを示す.tsファイルがあるかどうか確認してください（例えば"fr"はフランス、"de"はドイツ語です）
• ファイルがあれば、そのファイルはダウンロードできます（ファイルをクリックでダウンロード）。翻訳の修正、検討、改善が可能です。
• ファイルが存在しない場合、言語コードなしの.tsファイルをダウンロードしてください（あるいは他の.tsファイルでも同じです）
• そのファイル名をあなたの言語コードに変更してください。
• Qt-Linguistプログラムでそのファイルを開いてください。
• 翻訳を開始します（Qt Linguistは大変使いやすいプログラムです）
• 翻訳がすべて終わったらファイルを保存してください。
• ファイルを我々に送ってください。他のユーザへも役立てられるように、そのファイルをfreecadソースコードに含めます。

利用可能な翻訳ファイル

• FreeCAD main GUI
• Complete Workbench
• Drawing Workbench
• Draft Workbench
• Reverse Engineering Workbench
• FEM Workbench
• Robot Workbench
• Image Workbench
• Sketcher Workbench
• Mesh Workbench
• Test Workbench
• Points Workbench
• Raytracing Workbench
• Part Workbench
• PartDesign Workbench
• Assembly Workbench
• MeshPart Workbench

独自モジュール/アプリケーションの翻訳の準備

必要なもの

独自のアプリケーションモジュールをローカライズするにはQtの助けが必要になります。これらはTrolltech-ウェブサイトからダウンロードすることができますし、また、LibPackにも含まれています:

qmake

プロジェクトファイルを生成します

lupdate

ソースコードを調べてプロジェクトからオリジナルテキストを抽出したり更新したりします

Qt-Linguist

Qt-Linguistは非常に使いやすく、一般的な文章の慣用表現集のような便利な機能を持ち、あなたの翻訳を手助けします

プロジェクトのセットアップ

プロジェクトのローカライゼーションを始めるために、モジュールのGUI部分に移動し以下のコマンドを実行してください:

qmake -project

このコマンドはあなたのプロジェクトのディレクトリにあるテキスト文字列を含んでいるファイルを調べ、次の例のようなプロジェクトファイルを作成します:

######################################################################
# Automatically generated by qmake (1.06c) Do 2. Nov 14:44:21 2006
######################################################################

TEMPLATE = app
DEPENDPATH += .\Icons
INCLUDEPATH += .

# Input
HEADERS += ViewProvider.h Workbench.h
SOURCES += AppMyModGui.cpp \
           Command.cpp \
           ViewProvider.cpp \
           Workbench.cpp
TRANSLATIONS += MyMod_de.ts

手動でファイルを追加することができます。TRANSLATIONSセクションには言語ごとに翻訳されたファイルのリストがあります。上記の例ではMyMod_de.ts はドイツ語に翻訳されたファイルです。

次にlupdateを実行し、GUIに含まれる文字列リテラルを抽出する必要があります。ソースコードの変更後にlupdateを実行しても翻訳ファイルから文字列を削除することは決してないため、常に安全です。lupdateは新しい文字列を追加するだけです。

次にVisualStudioのプロジェクトへ.ts-filesを追加する必要があります。次のカスタムビルドメソッドを指定してください:

python ..\..\..\Tools\qembed.py "$(InputDir)\$(InputName).ts"
                "$(InputDir)\$(InputName).h" "$(InputName)"

注意:1行のコマンドラインで入力してください。ここではレイアウトのために改行しているだけです。

上記の例のように.ts-fileをコンパイルすることによって、ヘッダーファイル MyMod_de.hが作成されます。このファイルをインクルードする最適な場所はApp<Modul>Gui.cppです。今回の例ではAppMyModGui.cppになります。このファイルに次の行を追加してあなたの翻訳をアプリケーション内で公開しましょう。

new Gui::LanguageProducer("Deutsch", <Modul>_de_h_data, <Modul>_de_h_len);

pythonファイルの翻訳設定

pyファイルのローカライゼーションを簡単にするために複数のpｙファイルにも対応できる"pylupdate4"ツールが利用できます。-ts オプションをつけることで複数の.tsファイルの作成や更新が可能です。例えばフランス語のための.tsファイルを作成するには、コマンドラインに次のように入力するだけです:

pylupdate4 *.py -ts YourModule_fr.ts 

pylupdateツールは、pyファイルからtranslate()かtr()関数をスキャンし、YourModule_fr.tsファイルを作ります。このファイルはQLinguistによる翻訳が可能であり、QLinguistまたは次のコマンドでYourModule_fr.qmが作成されます:

lrelease YourModule_fr.ts

pylupdate4ツールはtranslate()関数をあまり精度よく認識しないことに注意してください。この関数は詳細な書式を必要とします（例としてドラフトモジュールファイルを参照してください）。ファイル内では以下のようにして翻訳システムを組み入れることが可能です（QApplicationのロード後、Qtウィジェットの作成前に行います）:

translator = QtCore.QTranslator()
translator.load("YourModule_"+languages[ln])
QtGui.QApplication.installTranslator(translator)

必要に応じて、以下の内容のXMLファイルDraft.qrcを作成することができます：

<RCC>
<qresource prefix="/translations" > 
<file>Draft_fr.qm</file> 
</qresource> 
</RCC> 

pyrcc4 Draft.qrc -o qrc_Draft.py を実行すると、全てのリソースを含む大きなPythonファイルを作成します。またこの方法で複数のアイコンファイルを1つのリソースファイルに入れることも可能です。

wikiを翻訳する

このwikiは多数のコンテンツを提供しています。最新の興味深い内容はマニュアルに集められています。

まず最初のステップはあなたの言語でのマニュアルの翻訳がすでに始まっているかどうかを確認することです（"マニュアル"の下の左側のサイドバーを見てみください）。

開始されていなければフォーラムに行き、新しい翻訳を始めたいと発言してください。我々はあなたが取り組みたい言語のための基本的な設定を作成します。

次にwikiの編集の許可を得なければなりません。

もしあなたの言語の翻訳が既に開始されている場合、まだ翻訳されていないページを見つけてください（リストに赤色で表示されています）。手順は単純です：赤いページに行き、対応する英語ページの内容をコピーして貼り付けます、そして翻訳を開始します。

もとの英語ページのすべてのタグとテンプレートを入れるのを忘れないでください。いくつかのテンプレートは、あなたの言葉の相当するテンプレートを持っているでしょう（例えば、Docnav/frはフランス語版のDocnavテンプレートです）。ほとんどの全てのリンクに対してスラッシュとあなたの言語コードを使わなければならないでしょう。やり方は翻訳済みの他のページを参考にしてください。

また[[Category:Developer Documentation/fr]]のようにカテゴリーにスラッシュとあなたの言語コードを追加してください。

ページの翻訳を終えたら、元の英語ページにあなたの翻訳へのリンクを加えなければなりません。これによって読者は {{languages}}テンプレートからそのページの翻訳版が利用できることがわかります。他の翻訳者のやり方を見て同じようにしましょう。

• 元の英語ページではあなたの言語をアルファベット順に従って追加してください： {{languages | {{es|Localisation/es}} {{fr|Localisation/fr}} {{jp|Localisation/jp}} {{se|Localisation/se}} }}
• あなたが翻訳しているページではあなたの言語のlanguage テンプレートを使用してまず英語を配置してから残りの言語をアルファベット順に従って追加してください： {{languages/fr | {{en|Localisation}} {{es|Localisation/es}} {{jp|Localisation/jp}} {{se|Localisation/se}} }}

もし自信がない場合、フォーラムに行き、正しいかどうかのチェックを依頼してください。

マニュアルページでよく使用される3つのテンプレートがあります。これら３つのテンプレートはローカライズバージョンを持っています。

• Template:Docnav :ページの下にあるナビゲーションバーです。「前のページ」や「後のページ」を示します
• Template:Languages :このテンプレートは元のページに配置し、読者にそのページの翻訳版が存在することを示します。翻訳版のページには英語ページへのリンクを張らなければなりません。
• Template:en ：各言語ごとに用意されたアイコンの一つです。languagesテンプレート内に配置します。

ページの命名規則

MediaWikiエンジンのSourceforge実装の制限のために、あなたのページの名前を、元の英語ページの名前にスラッシュとあなたの言語コードを追加した名前にする必要があるので注意してください。例えばAbout FreeCADの翻訳されたページは、スペイン語ならAbout FreeCAD/es、ポーランド語ならAbout FreeCAD/plといった具合になります。この理由は単純に翻訳者が去った場合にwikiの管理者が(すべての言語を話せるわけではないので）それらのページが何であるかを知るためです。またメンテナンスを容易にしてページが失われるのを避けるためでもあります。

Docnavテンプレートのリンク先のページ名をあなたの言語で表示したい場合、リダイレクトページを使用します。これは基本的には実際のページへのショートカットリンクです。以下はAbout FreeCADのフランス語のページの例です。

• About FreeCAD/frは実際のページです
• ページÀ propos de FreeCADでは次のコードを持ちます：

#REDIRECT [[About FreeCAD/fr]]

• About FreeCAD/frのページではDocnavのコードは次のようになります：

{{docnav/fr|Bienvenue sur l'aide en ligne|Fonctionnalités}}

ページ"Bienvenue sur l'aide en ligne"はOnline Help Startpage/frにリダイレクトし、ページ"Fonctionnalites"はFeature list/frへリダイレクトします.

不明な点があれば遠慮しないでフォーラムで聞きましょう 。

あなたのシステムのPythonインストール設定に新しいモジュールを追加することでFreeCAD内部のPythonモジュールを簡単に拡張することができます。これらのモジュールはFreeCADによって自動的に検知され使用されます。

Pythonモジュールは全てFreeCADの内部から使用できますが中でも以下で紹介するいくつかのものは特に重要です。なぜならこれらを使うとPythonプログラムからFreeCADの中核機能に対して完全なアクセスを行うことが可能だからです。これらのモジュールの使用例はコードスニペットページにあります。

注意:：

• 以下のモジュールの内、Pivyは既にFreeCADインストールパッケージに完全に統合されています。またWindows用インストールパッケージではPyQt4も統合されています。
• PyQt4はバージョン0.13以降、次第にサポートされなくなっていく予定です。これは完全に同じ機能持つものの、よりFreeCADと互換性の高いライセンス（LGPL）を持つPySideに移行するためです。

PyQt4

ホームページ： http://www.riverbankcomputing.co.uk/pyqt

PyQt（バージョン4）はプログラムがQtインターフェイスに対してアクセスしたり、それらを作成、変更できるようにするためのPythonバインディングライブラリです。FreeCADのインターフェイスはQtで作られているので、あなたのシステムにPyQt4をインストールすることでFreeCAD内部のPythonプログラムからインターフェイス全てにアクセスしたり、パーツの変更や新しいウィジットの作成、インターフェイスのパーツから情報を集めるなどの処理を行えるようになります。

PyQtはQtで使われているものと同じマルチライセンスシステムの下でリリースされています。つまり商用ライセンス版とフリーなGPL版がアルのです。もし商用の（クローズドなソースの）プログラムで使用したいと思ったら商用ライセンスを購入する必要があります。一方、GPL版では自由にインストールして使用することだけができます。

インストール

言うまでもないでしょうがPyQt4をインストールする前にインストール済みの正常動作するPython環境が必要です。

Linux

最も簡単なPyQt4のインストール方法はあなたの使っているディストリビューションのパッケージマネージャーを使用する方法です。Debian/Ubuntuシステムではパッケージ名は一般的にはpython-qt4です。またRPMベースのシステムではpyqt4となっています。必要な依存関係（QtとSIP）は自動的に解決されます。

Windows

プログラムをここからダウンロードできます。pyqt4をインストールする前にQtライブラリとSIPライブラリをインストールしておく必要があります（要ドキュメント化）。

使用方法

インストールが終わったらFreeCADにPythonコンソールで以下のコマンドを入力して全て動作しているかどうかチェックします：

import PyQt4

FreeCADインターフェイスにアクセスするには以下のように入力します：

from PyQt4 import QtCore,QtGui
app = QtGui.qApp
FreeCADWindow = app.activeWindow()

以上を行うとdir()コマンドを使ってインターフェイスを探索できるようになります。自作のウィジットなど新しい要素を追加するには以下の様なコマンドを使います：

FreeCADWindow.addDockWidget(QtCore.Qt.RghtDockWidgetArea,my_custom_widget)

ドキュメント

以下に（QtDesigneやPythonを使ったインターフェイスの作成方法を含む）もっと詳しいpyQt4のチュートリアルがあります：

http://www.riverbankcomputing.co.uk/static/Docs/PyQt4/html/classes.html - 公式PyQt4 APIリファレンス

http://www.rkblog.rk.edu.pl/w/p/introduction-pyqt4/ - 簡単なイントロダクション

http://www.zetcode.com/tutorials/pyqt4/ - 非常に詳細なチュートリアル

Pivy

ホームページ： http://pivy.coin3d.org/

PivyはPython用のCoinバインディングライブラリで、Coinプロジェクトによって公式にサポートされています。Coin自体はOpenGLで3Dアプリケーションを作成するためのツールキットです。FreeCADはこのツールキットを使って画面上に3Dシーンを描画しています。あなたのシステムにPivyをインストールするとPythonプログラムからFreeCADのシーングラフにアクセスして画面上に新しいオブジェクトを描画したり、描画操作用の幅広いCoinツールを利用できるようになります。Coinはシーン記述言語であるOpenInventorに基づいています。PivyはFreeCADの2D製図モジュール（また全てのモジュール）で使用されているのでそれらのモジュールのツールを使いたい場合には必ず必要になります。

FreeCADではオブジェクトを画面上に表現するためにしかCoinを使っておらず、それらはオブジェクトの定義とは分離しているということは知っておくべき重要な点でしょう。つまりPivyを使って既存のオブジェクトを変更したり、正常なFreeCADオブジェクトを作成することはできないのです。ただし一時的なものであれば、座標軸、グリッド、マニピュレータ、補助ジオメトリーなどあらゆるものを画面に描画することができます。

PivyはCoinと同様、GPLライセンスの下でリリースされています。

インストール

必要条件

Pivyをコンパイルする前にはCoinとSoQtをインストールしておいた方がいいと思います。

Mac上でのビルドではCoin3バイナリパッケージをインストールするだけで十分でした。ただしMacPortsからCoinをインストールしようとすると問題となるかもしれません。大量のXWindowパッケージの追加を行わなければならず、スクリプトのエラーによる完全なクラッシュもありました。

FedoraではRPMにCoin3がありました。

SoQtのソースからのコンパイルはMacでもLinuxでも問題ありませんでした。

Debian & Ubuntu

DebianSqueezeとUbuntuLucidを使って始める場合は公式レポジトリからPivyを直接利用することができるのでたいして面倒ではないでしょう。他にもダウンロードページから利用できる私たちが（DebianとUbuntuKarmic用に）作成したパッケージをダウンロードするか、あるいは自分自身でビルドするという方法をとることもできます。

最も簡単なPivyのコンパイル方法はPivyのDebianソースパッケージから取ってきてdebuildを使ってパッケージを作成するやり方です。これはPivyの公式サイトのものと同じソースコードですがDebianの人たちによっていくつかのバグ修正が追加されています。UbuntuKarmic上でも正常にコンパイルできます： http://packages.debian.org/squeeze/python-pivy から.orig.gzファイルと.diff.gzファイルをダウンロードして両方を展開したら.diff をソースに適用します。展開したPivyのソースフォルダに移動し、以下のようにして.diffパッチを適用します：

patch -p1 < ../pivy_0.5.0~svn765-2.diff

その後で次のコマンドをを実行するとPivyが公式なインストールパッケージに適切にビルドされます。

debuild

それが終わったらgdebiを使ってそのパッケージをインストールすれば終わりです。

そのほかのLinuxディストリビューション

まず以下のコマンドを使って最新のソースをプロジェクトのリポジトリ:から入手します。

hg clone http://hg.sim.no/Pivy/default Pivy

2012年3月現在、最新のバージョンはPivy-0.5です。

次にPythonバインディング用のC++コードを生成するためのSWIGというツールが必要になります。Pivy-0.5はSWIG 1.3.31、1.3.33、1.3.35、1.3.40でのみテスト済みであると説明されています。従ってそれら古いバージョンのどれかのソースのtarballをhttp://www.swig.orgからダウンロードします。ダウンロードしたら展開して（root権限で）次のコマンドを実行します：

./configure
make
make install （checkinstallを使っている場合はそれでも構いません）

ビルドは数秒で終わります。

あるいはもっと新しいSWIGを使ってビルドを試みてもいいでしょう。2012年3月現在、標準のリポジトリバージョンは2.0.4です。PivyはMac OSでのSWIG 2.0.4を使ったコンパイルでちょっとした問題がありますが（下記を参照）、Fedora Core 15では正常にビルドできるようです。

ビルドが終わったらPivyソースの位置に移動し、次のコマンドを実行します：

python setup.py build 

これによってソースファイルが作成されます。ビルドでは大量の警告が出る場合がありますが恐らくエラーはでないでしょう。

恐らく今は修正されていますが 'char*'を'const char*'に変換できない、というコンパイルエラーが起きる場合があります。これを修正するためには該当する行に'const'を書き込む必要があります。修正ヶ所は6行あります。

それが終わったら次のコマンドを（root権限で）実行してインストールを行います：

python setup.py install （またはcheckinstall python setup.py install）

これで終わりです。Pivyがインストールされました。

Mac OS

以下の手順説明は完全ではないかもしれません。2012年3月現在、OS10.7でほぼ動作しました。レポジトリはMacPortsのものを使用しましたが他のものでもうまくいくはずです。

Linuxと同様に最新のソースコードを以下のコマンドで入手します：

hg clone http://hg.sim.no/Pivy/default Pivy 

もしあなたの環境にhgがなければ以下のコマンドを実行することでMacPortsから入手できます：

port install mercurial

その後は上記と同様、SWIGが必要になります。以下のコマンドで入手できるはずです：

port install swig

私の環境では以下のコマンドも必要でした：

port install swig-python

2012年3月現在、MacPortsのSWIGはバージョン2.0.4です。上記のLinuxの項目で書いたように可能であればもっと古いバージョンをダウンロードした方が良いでしょう。SWIG2.0.4にはPivyのビルドが止まるバグがあるようです。以下の要約の最初のメッセージを参照して下さい： https://sourceforge.net/mailarchive/message.php?msg_id=28114815

これはソース内の二ヶ所を編集してarg4、arg5の代わりに修飾参照*arg4、*arg5を追加することで修正できます。これで以下のコマンドを使ってPivyをビルドできるはずです：

python setup.py build
sudo python setup.py install

Windows

VisualStudio2005以降を使用するものとします。ツールメニューの'Visual Studio 2005 Command prompt'を使ってコマンドプロンプトを開きます。 もしPythonインタプリタをまだシステムパスに登録していない場合は以下のようにしてください：

set PATH=path_to_python_2.5;%PATH%

Pivyを動作させるためにはプロジェクトのリポジトリから最新のソースを入手します：

svn co https://svn.coin3d.org/repos/Pivy/trunk Pivy 

次にPythonバインディング用のC++コードを生成するためのSWIGというツールが必要になります。最新バージョンではなくSWIGのバージョン1.3.25を使うことをお勧めします。今のところPivyは1.3.25を使った場合にしか正しく動作しないためです。http://www.swig.orgから1.3.25のバイナリをダウンロードしてください。ダウンロードしたら展開して以下のようにしてコマンドラインからシステムパスに追加します：

set PATH=path_to_swig_1.3.25;%PATH%

またCOINDIRを適切なパスに設定します：

set COINDIR=path_to_coin

Windows上ではPivyの設定ファイルはデフォルトのSoQtではなくSoWinとなっているはずです。SoQtを使ってビルドする適切な方法を見つけられなかったので私はsetup.pyを直接変更しました。 200行目の 'sowin'の部分を取り除くだけです：（'gui._sowin', 'sowin-config', 'pivy.gui.'） （丸括弧閉じは削除しないように）

それが終わったらソースの位置に移動して以下のコマンドを実行します：

python setup.py build 

これによってソースファイルが作成されます。いくつかのヘッダファイルが見つからないというコンパイルエラーが起きるかもしれません。その場合にはINCLUDE変数を以下のように調整してください：

set INCLUDE=%INCLUDE%;path_to_coin_include_dir

もしSoQtのヘッダがCoinのヘッダと同じ場所にない場合は以下も行います：

set INCLUDE=%INCLUDE%;path_to_soqt_include_dir

最後にQtのヘッダを追加します：

set INCLUDE=%INCLUDE%;path_to_qt4\include\Qt

あなたがVisualStudioのExpressエディションを使っている場合、Pythonのkeyerror例外が起きるかもしれます。 その場合はPythonインストール位置にあるmsvccompiler.pyに若干の変更を加える必要があります。

122行目に移動し以下の行を

vsbase = r"Software\Microsoft\VisualStudio\%0.1f" % version

次の行で置き換えます。

vsbase = r"Software\Microsoft\VCExpress\%0.1f" % version

それが終わったらもう一度試してみてください。 次に示すようなエラーが再度起きた場合は

error: Python was built with Visual Studio 2003;...

128行目の以下の行を

self.set_macro("FrameworkSDKDir", net, "sdkinstallrootv1.1")

次の行で置き換えます。

self.set_macro("FrameworkSDKDir", net, "sdkinstallrootv2.0")

再度、試します。また次に示す様なエラーが起きる場合は

error: Python was built with Visual Studio version 8.0, and extensions need to be built with the same version of the compiler, but it isn't installed.

以下のコマンドで環境変数のDISTUTILS_USE_SDKとMSSDKを調べてみてください。

echo %DISTUTILS_USE_SDK%
echo %MSSDK%

もしまだ設定されていないようであれば以下のコマンドの様にして1などを設定してください。

set DISTUTILS_USE_SDK=1
set MSSDK=1

また'char*'を'const char*'に変換できない、というコンパイルエラーが起きる場合があります。これを修正するためには該当する行に'const'を書き込む必要があります。修正ヶ所は6行あります。 ビルドが終わったら生成されたPivyディレクトリをFreeCADのPythonインタプリタが見つけられる場所にコピーしてください。

使用方法

PivyでFreeCADのシーングラフにアクセスするには次のようにします：

from pivy import coin
App.newDocument() # ドキュメントとビューを開きます
view = Gui.ActiveDocument.ActiveView 
FCSceneGraph = view.getSceneGraph() # Coinシーングラフのメイン"コンテナ"であるSoSeparatorを保持したPivyのPythonオブジェクトを返します
FCSceneGraph.addChild(coin.SoCube()) # シーンにボックスを追加します

これでdir()コマンドを使ってFCSceneGraphを調べることができるようになります。

ドキュメント

残念なことにPivyについて書かれたものはネット上にはまだほとんどありません。ただしCoinドキュメントが利用できることにあなたは気がついたかもしれません。PivyはConiの関数、ノード、メソッドを純粋にPythonに移植したものだからです。名前とプロパティは全て同じままで、気をつける必要があるのはCとPythonの文法の違いだけです。

http://doc.coin3d.org/Coin/classes.html - Coin3DのAPIリファレンス

http://www-evasion.imag.fr/~Francois.Faure/doc/inventorMentor/sgi_html/index.html - The Inventor Mentor - Inventorのシーン記述言語の"バイブル"です

またFreeCADのMod/DraftフォルダにあるDraft.pyファイルを参照してもいいでしょう。これはPivyを豊富に使っているからです。

pyCollada

pyColladaはプログラムでCollada (*.DAE)ファイルの読み書きを行うことができるようにするためのPythonライブラリです。pyColladaがあなたのシステムにインストールされている場合にはFreeCAD（available in version 0.13 ）はそれを検出してColladaファイル形式のインポートとエクスポートを行うハンドルの追加を行います。

インストール

pyColladaは今のところLinuxディストリビューションのレポジトリでは利用できないことが多いですが、Pythonファイルだけで作成されていてコンパイルを必要としないのでインストールは簡単です。やり方は二通りあります。pyColladaの公式Gitレポジトリから直接インストールするか、easy_installツールを使うかのどちらかです。

Linux

どちらの場合でも以下のパッケージがあなたのシステムにインストールされている必要があります：

python-lxml 
python-numpy
python-dateutil

Gitレポジトリからのインストール

git clone git://github.com/pycollada/pycollada.git pycollada
cd pycollada
sudo python setup.py install

easy_installを使ったインストール

Pythonは既に完全にインストールされているものとし、その場合、easy_installユーティリティが既に存在しているはずです。

easy_install pycollada

pyColladaが正しくインストールされたかどうか確認するためにはPythonコンソールで以下のコマンドを入力します：

import collada

何も返らなければ（エラーメッセージがでなければ）全てOKです。

Windows

ドキュメント作成予定

IfcOpenShell

IFCOpenShellは現在開発中のライブラリでIndustry foundation Classes (*.IFC)のインポート（いずれはエクスポートも）を行えるようにするもので。IFCはSTEP形式の拡張でBIMワークフローでの標準形式になる予定です。あなたのシステムにIFCOpenShellが正しくインストールされている場合にはFreeCADの建築モジュール がそれを検出してIFCファイルのインポートに使用します。IFCOpenShellはFreeCAD同様、OpenCasCadeを基盤にしていてインポートの精度が非常に高く、高品質なソリッドジオメトリを生成します。

ホームページ： http://www.ifcopenshell.org

インストール

IFCOpenShellは非常に新しいものなので恐らく自分でコンパイルする必要があります。

Linux

IFCOpenShellをコンパイルするためにはシステムにいくつかの開発用パッケージをインストールする必要があります：

liboce-*-dev
python-dev
swig

ただしこれらは全てFreeCADでも必要な物なので、もしあなたがFreeCADをコンパイルできる状態なら他にIfcOpenShellをコンパイルするのに必要な物はありません。

以下から最新のソースコードを入手してください：

svn co https://ifcopenshell.svn.sourceforge.net/svnroot/ifcopenshell ifcopenshell

ビルド処理は非常に簡単です：

mkdir ifcopenshell-build
cd ifcopenshell-build
cmake ../ifcopenshell/cmake

あるいは、あなたがOpenCasCadeの代わりにoceを使っている場合は以下の様になります：

cmake -DOCC_INCLUDE_DIR=/usr/include/oce ../ifcopenshell/cmake 

IfcOpenShellは元々はBlender用に作成されたのでデフォルトではpython3を使用します。FreeCAD内部で使用する場合にはFreeCADで使用されているものと同じバージョンのPythonに対してコンパイルを行う必要があります。従って以下のようにして追加のCMakeパラメータでPythonのバージョンを指定する必要があるでしょう（Pythonのバージョンを調整するのです）。

cmake -DOCC_INCLUDE_DIR=/usr/include/oce -DPYTHON_INCLUDE_DIR=/usr/include/python2.7 -DPYTHON_LIBRARY=/usr/lib/python2.7.so ../ifcopenshell/cmake

その後で以下を実行します：

make
sudo make install

IfcOpenShellが正しくインストールされたかどうか確認するためにはPythonコンソールで以下のコマンドを入力します：

import IfcImport

何も返らなければ（エラーメッセージがでなければ）全てOKです。

Windows

IfcOpenShellのREADMEファイルからの転載です

win/ folderにあるVisual Studioの.slnファイルを使用することをお勧めします。Windowsユーザー用ビルド済みバージョンのOpenCASCADEはウェブサイト http://opencascade.org から利用可能です。このバージョンをダウンロードしてインストールした後でOpenCASCADEのヘッダとライブラリのパスをMS Visual Studio C++に設定してください。

IfcPythonラッパーをビルドするためにはSWIGが必要になります。 http://www.swig.org/download.html から最新版のswigwinをダウンロードしてください。.zipファイルを展開したら、その展開したフォルダをPATH環境変数に追加してください。またPythonがインストールされている必要があります。そのインクルードとライブラリパスをVisualStudioに設定してください。

クレジット

長期にわたってFreeCADへの貢献を続けてくれている人々と企業の一覧です。サードパーティー製ライブラリーのクレジットについてはサードパーティー製ライブラリーのページを見てください。

開発

プロジェクトマネージャー

FreeCADプロジェクトの開発者リーダー

• Jürgen Riegel
• Werner Mayer

メイン開発者

普段からFreeCADのコード上で作業してくれている人々

• Yorik van Havre
• Logari81
• Mrlukeparry

その他のプログラマー

FreeCADプロジェクトにコードを提供してくれた人々

• Graeme van der Vlugt
• Berthold Grupp
• Georg Wiora
• Martin Burbaum
• Jacques-Antoine Gaudin
• Ken Cline
• Dmitry Chigrin
• Migius - Remigiusz Fiedler (DXFパーサー)

企業

コードや開発者を提供してくれている企業

• Imetric 3D

コミュニティー

FreeCADプロジェクトを手助けするために多大な努力を払ってくれているコミュニティーの人々

• Normandc
• Kwahoo
• Eduardo Magdalena