Manual/ru

From FreeCAD Documentation
Jump to: navigation, search

Это руководство по программе FreeCAD. Оно включает в себя важные части wiki документации по FreeCAD. Оно создано для просмотра или печати как один большой документ. Если Вы хотите изучать это руководство по частям, Вы можете обратиться к Online-версии, которая удобнее для просмотра.


150

Добро пожаловать на страницу помощи FreeCAD

Этот вики документ был создан автоматически из содержимого официальной вики документации FreeCAD, которую можно прочитать в Интернете по адресу http://www.freecadweb.org/wiki/index.php?title=Main_Page/ru. Так как вики активно поддерживается и постоянно развивается сообществом FreeCAD разработчиков и пользователей, Вы можете обнаружить, что онлайн-версия содержит больше или более новую информацию, чем этот документ. Здесь так же можно найти текущий перевод документации на несколько языков. Но всё же, мы надеемся, что Вы найдёте здесь всю необходимую информацию. В случае, если у Вас есть вопросы, на которые не можете найти ответы в данном документе, посмотрите на форуме FreeCAD. Там, возможно, Вы сможете найти ответ на Ваш вопрос, или кто-то сможет Вам помочь.

Как использовать

Этот документ состоит из нескольких разделов: введение, использование, написание сценариев и разработка. Последние три раздела предназначены для трёх разных категорий пользователей FreeCAD: обычные пользователи, которые просто хотят использовать эту программу, опытные пользователи, которые интересуются возможностью написания сценариев в FreeCAD и хотели бы изменить некоторые ее аспекты, и разработчиков, которые будут помогать разрабатывать FreeCAD или использовать её в качестве базы для разработки собственных приложений. Если Вы новичок в FreeCAD, мы рекомендуем просто начать с введения.

Содействие

Как Вы, возможно, заметили, программисты не умеют писать справку для изучения программ. Для них всё совершенно ясно, потому что они сами это так сделали. Поэтому очень важно, что опытные пользователи помогают нам писать и пересматривать документацию. Да, мы имеем в виду Вас! Как, спросите Вы? Просто зайдите в Wiki на http://www.freecadweb.org/wiki/index.php?title=Main_Page/ru в раздел пользователя. Вам нужна учётная запись на Wiki FreeCADа, чтобы войти. Спросите на форуме или на канале IRC права на редактирование wiki (wiki защищена от записи из-за опасности спама), и мы сделаем учётную запись для Вас. В настоящее время учётная запись wiki и форума раздельны, но имя учётной записи на wiki будет такой же, что и на форуме. После этого Вы сможете начать редактирование! Так же посмотрите страницу http://www.freecadweb.org/wiki/index.php?title=Help_FreeCAD, чтобы узнать, как ещё Вы можете помочь FreeCAD.

Введение

Freecad default.jpg

FreeCAD это универсальный параметрический 3D моделлер или иными словами САПР , чья разработка полностью базируется на принципах Открытого исходного кода (LGPL License). FreeCAD непосредственно нацелен на разработку в машиностроении и дизайне объектов но также подходит для более широкого круга применений в инженерных задачах, таких как архитектура, анализ методом конечных точек, 3D печать, и других.

Во FreeCAD имеются инструменты аналогичные Catia, SolidWorks или Solid Edge, и, следовательно, он также попадает в категорию САПР, PLM, CAx и CAE. Это параметрический моделлер с модульной программной архитектурой, которая позволяет предоставлять дополнительные функциональные возможности без изменения базовой системы.

Как и во многих пакетах САПР, в нем много 2D-компонентов для создания плоских фигур или создания рабочих чертежей. Однако прямое 2D-рисование (как например в Inkscape или AutoCAD LT) не является основным, так же как анимация или редактирование сеток (например Blender, Maya, 3ds Max, или Cinema 4D). Тем не менее, благодаря своей широкой адаптивности, FreeCAD может оказаться полезным в гораздо более широкой области, чем его текущая сфера деятельности.

FreeCAD интенсивно использует библиотеки с открытым исходным кодом, существующие в области научных вычислений. Среди них Open Cascade Technology (OCCT), мощное ядро САПР; Coin3D, инструментарий для разработки 3D-графики, совместимый с Open Inventor; Qt, всемирно известный пользовательский интерфейс; и Python, современный язык сценариев. Сам FreeCAD также может быть использован в качестве библиотеки другими программами.

FreeCAD так же полностью мультиплатформенное приложение, и теперь работает на системах Windows, Linux/Unix и Mac OSX, с абсолютно идентичным видом и функциональностью на всех платформах.

Насчёт дальнейшей информации о возможностях FreeCAD's, смотрите статьи "Основные возможности", "Новости последних выпусков" или "Для начинающих", или посмотрите скриншоты.

О проекте FreeCAD

Проект FreeCAD начался в далёком 2001 году, как описано на странице его истории.

FreeCAD поддерживается и проектируется сообществом энтузиастов, проектировщиков и пользователей (смотри страницу contributors). Они работают на FreeCAD добровольно, в свободное время. Они не могут гарантировать, что FreeCAD содержит всё, что Вы можете пожелать, но они делают всё, что могут! Сообщество зовёт на форум FreeCAD, где обсуждается большая часть идей и пожеланий. Смело присоединяйтесь к нам здесь!

Это не полный список реализованных возможностей FreeCAD. Если вы хотите заглянуть в будущее, посмотрите Планы разработчиков для быстрого ознакомления планируемых нововведений. Прекрасной отправной точкой могут стать скриншоты.

Заметки о выпусках

Ключевые особенности

  • Feature1.jpg
    Геометрическое ядро, основанное на OpenCasCade, позволяет производить сложные трёхмерные операции над сложными типами форм, со встроенной поддержкой таких понятий, как: структуры B-Rep, NURBS, бинарные операции или fillets и встроенную поддержку форматов STEP и IGES
  • Feature3.jpg
    Полностью параметрическая модель данных. Объекты FreeCAD параметрические в основе, то есть их форма может полностью зависеть от параметров или даже зависеть от других объектов, все изменения пересчитываются по запросу, и записываются в стеке отмен-возвратов. Легко могут быть добавлены новые объекты, которые могут быть даже написаны на python
  • Feature4.jpg
    Модульная архитектура, позволяющая добавлять функциональность через плагины (модули). Эти расширения могут быть комплексными и программироваться на C++, или простыми как скрипты Python или записываемые самостоятельно макросы. У Вас есть полный доступ из встроенного интерпретатора Python, макросов или внешних сценариев к практически любой части FreeCAD, позволяя создавать и изменять геометрию, двумерное и объёмное представление этой геометрии (scenegraph) или даже интерфейс FreeCAD
  • Feature5.jpg
    Импорт/экспорт в стандартные форматы, такие как: STEP, IGES, OBJ, STL, DXF, SVG,U3D, DAE, IFC, OFF, NASTRAN, VRML, кроме собственного формата FreeCAD Fcstd. Уровень совместимости между FreeCAD и данными форматами может различаться, поскольку зависит от поддерживающего их модуля.
  • Feature7.jpg
    Модуль эскизирования с решателем ограничений, позволяющий создавать эскизы с геометрически ограниченными двухмерными формами. Он позволяет построить несколько типов геометрий с ограничениями, и использовать их в качестве базы для построение других объекто в спомощью FreeCAD.
  • Feature9.jpg
    Модуль робототехники позволяет изучать движения роботов. Этот модуль уже имеет расширенный графический интерфейс, позволяющий работать чисто через него
  • Feature8.jpg
    Удобный новый модуль для создания традиционных чертежей с опциями вроде видов детализации, сечений, образмеривания и других, которые позволяют поместить на лист двумерный вид вашей трёхмерной модели. Эти модули создают листы, готовые к экспорту в SVG или PDF. В то же время оставлен прежний модуль черчения с его небогатыми возможностями графического интерфейса, но мощной функциональностью через Python.
  • Feature-raytracing.jpg
    Модуль рендеринга может экспортировать 3D объекты для рендеринга во внешние программы. Пока что он поддерживает только POV-Ray и LuxRender
  • Feature-arch.jpg
    Модуль архитектуры позволит работать с BIM(информационная модель здания), совместимой с форматом IFC.
  • Feature-CAM.jpg
    Модуль Path посвящён механической обработке вроде фрезерования (CAM), и может выводить, показывать и настраивать G-код.

Общие черты:

  • FreeCAD является мультиплатформенным приложением. Он запускается и ведет себя схожим образом на платформах Windows, Unix/Linux и macOS.
  • FreeCAD приложение с полноценным ГИП. FreeCAD обладает законченным Графическим Интерфейсом Пользователя, основанном на известном инструментарии Qt, с 3D просмотрщиком, основанным на Open Inventor, позволяющим быстро отрисовывать 3D сцены и обладающим весьма доступным представлением сцены в виде графа.
  • FreeCAD также работает как приложение командной строки при низком объёме памяти. В режиме командной строки FreeCAD запускается без графического интерфейса, но со всеми инструментами геометрии. Например, это может быть использовано в качестве сервера для получения содержимого от других приложений.
  • FreeCAD может быть импортирован как модуль Python внутрь других приложений, способных запускать сценарии python, или в консоль python. В этом режиме как в консольном режиме часть интерфейса FreeCAD недоступна, но все геометрические инструменты доступны.
  • Концепция инструментариев: В интерфейсе FreeCAD инструменты сгруппированы по инструментариям. Это позволяет отображать только инструменты, используемые для выполнения конкретной задачи, сохраняя рабочее пространство отзывчивым и незагромождённым, а приложение быстро загружаемым.
  • Расширяемая структура позволяющая подключать Плагины/Модули для последующей загрузки типов данных/функциональностей. FreeCAD разделён на основное приложение и модули, которые загружаются только при необходимости. Почти все инструменты и типы геометрии хранятся в модулях. Модули ведут себя как плагины, и могут быть добавлены или удалены из существующей установленной версии FreeCAD.
  • Параметрические объекты связанные с документом: Все объекты в FreeCAD документе могут быть заданы параметрами. Эти параметры можно менять налету, и пересчитывать в любое время. Также хранятся отношения между объектами, так что изменения одного объекта также изменят зависящие от него объекты.
  • Создание параметрических примитивов (куб, сфера, цилиндр и т.д.).
  • Графические модификационные операции вроде трансляции, поворота, масштабирования, отражения, смещения (простого или после Jung/Shin/Choi ) или изменение формы, в любой плоскости трёхмерного пространства
  • Графическое создание планарной геометрии вроде линий, ломаных, прямоугольников, сплайнов, дуг или окружностей на любой плоскости трехмерного пространства
  • Моделирование с прямым или перевёрнутым выдавливанием, сечением и fillets.
  • Топологические компоненты вроде вершин, ребер, ломаных и плоскостей (в том числе через скрипты на Python).
  • Инструменты тестирования и востановления для сеток: твёрдотельный тест, тест non-two-manifolds (топологическое многообразие), тест на самопересечение, заполнение прорывов и однородное расположение.
  • Аннотации как надписи или размеры
  • Возможность Отменить/Вернуть действие: Все отменяемо/возвращаемо, с доступом к стэку выполненных действия, так что единовременно может быть отменено множество шагов.
  • Управление запросами: Стек отмен/возвратов хранит запросы к документу а не одиночные действия, что позволяет каждому инструменту точно определить, что должно быть отменено или переделано.
  • Структура позволяющая встраивать свои сценарии: FreeCAD обладает встроенными Python интерпретатором и API, которые охватывают практически любую часть предложения, интерфейса, геометрии и представления этой геометрии в 3D просмотрщике. Интерпретатор может запускать как одиночные команды, так и сложные сценарии. На самом деле входящие модули могут даже быть полностью запрограммированы в Python.
  • Встроенная консоль Python с подсвечиванием синтаксиса, автодополнением и просмотром классво: команды Python могут быть выполнены прямо в FreeCAD и напрямую возвращать результаты, позволяя программистам тестировать работу на ходу, раскрывая содержимое модулей и легко изучая внутренности FreeCAD.
  • Пользовательские действия отражаются в консоли: Всё, что пользователь делает в интерфейсе FreeCAD, выполняется в виде кода Python, который может быть выведен в консоль и записан в макрос.
  • Полная запись и редактирование макросов: Команды Python, которые вызываются при манипулировании пользовательским интерфейсом, могут быть записаны, отредактированы и сохранены для дальнейшего использования.
  • Составной (основанный на ZIP) формат хранения документов: документы FreeCAD с расширением .fcstd могут содержать множество различных типов информации, таких как геометрия, сценарии или иконки миниатюр. Файл .fcstd представляет собой архив zip, так что сохранённый файл FreeCAD уже заархивирован.
  • Полностью настраиваемый/сценарируемый Графический Интерфейс Пользователя. Основанный на Qt интерфейс FreeCAD полностью доступен из интерпретатора Python. Помимо простых функций самого FreeCAD предоставляются инструментарии, а также полный доступ к структуре Qt, что позволяет выполнять любые операции с ГИП, такие как создание, документирование, изменение и удаление виджетов и панелей инструментов.
  • Миниатюры (на данный момент только в Linux системах): Значки документа FreeCAD, показывающие содержимое файла в большинстве файловых менеджеров таких как Nautilus в Gnome.
  • Модульная установка в MSI производит гибкую установку на Windows системы. Пакеты для системы Ubuntu также поддерживаются

В процессе развития

  • Feature-assembly.jpg
    Модуль Assembly, который позволяет работать с несколькими проектами, несколькими формами, несколькими документами, несколькими файлами, несколькими связями... Это модуль пока на стадии планирования.

Дополнительные верстаки

Опытные пользователи могут создавать различные пользовательские внешние верстаки.


Загрузка


Учтите, что на наш взгляд, FreeCAD ещё не достиг статуса версии 1.0 и, возможно, не готов для промышленного применения. Несмотря на это, множество людей использует FreeCAD. Чтобы выяснить подойдёт ли FreeCAD для вашего проекта, см. форум FreeCAD.

Текущая стабильная версия

Первый выпуск FreeCAD 0.17 (0.17.13509) опубликован 06.04.2018. Выпуск с исправлениями ошибок 0.17.13528 опубликован 13.07.2018. Чтобы узнать о нововведениях, см. замечания о выпуске.

You will find SHA256 checksums to verify integrity of your download on the 0.18.3 release page.

Windows.png

Windows

32-bit | 64-bit

Mac.png

Mac

Mac OS X 64-bit

AppImage-logo.png

Linux

AppImage 64-bit

Примечание для пользователей Windows

Поддерживаются следующие версии:

  • 32-битный установщик (x86): Windows 7/8/10
  • 64-битный установщик (x64): Windows 7/8/10

Примечание для пользователей Mac OS X

Минимальная поддерживаемая версия: Mac OS X 10.11 El Capitan.

Примечание для пользователей Linux

FreeCAD может быть установлен в большинстве дистрибутивов Linux из их официальных репозиториев программ. Но предлагаемая в репозиториях версия может быть достаточно старой и по этой причине не иметь некоторых возможностей. Вместо установки из репозитория вы можете загрузить AppImage по ссылке сверху, разрешить загруженному файлу права на исполнения и запустить его без установки. Для дальнейшей информации об установке, и в том числе, о том как получить свежие пакеты для Ubuntu и производных дистрибутивов см. установка на Unix.

Please see the Install on Unix page for more installation options, including daily packages for Ubuntu and derivatives.

Разрабатываемые версии

Разработка FreeCAD ведётся постоянно! Вы хотите получить разрабатываемый выпуск 0.18? Забирайте на странице выпусков FreeCAD.

Дополнительные модули и макросы

Сообщество FreeCAD предлагает множество различных модулей и макросов. Они могут быть легко установлены напрямую из FreeCAD через Менеджер дополнений.

Установка

Установка в Windows


Наиболее лёгкий способ установить FreeCAD под Windows - это загрузить одну из программ установки по ссылке ниже.

Windows.png Windows 32 bit (sha256)

Windows.png Windows 64 bit (sha256)


После загрузки файла .msi (Microsoft Installer)дважды щёлкните по нему мышкой для начала установки.

Далее приведена информация о технических опциях. Если она выглядит обескураживающей, не волнуйтесь! Большинству пользователей Windows не потребуется ничего кроме файла .msi чтобы установить FreeCAD и начать с ним работу!


Простая установка c Microsoft Installer

Простейший способ установить FreeCAD на Windows - использовать пакет загружаемой программы установки выше. Эта страница описывает использование и возможности Microsoft Installer для дополнительных опций установки.

Если вы хотите загрузить версию для разработчиков (которая может быть нестабильной), см. страницу Загрузки.

Установка из командной строки

В утилите командной строки msiexec.exe доступны дополнительные особенности, такие как не интерактивная установка и административная установка. Смотрите примеры ниже.

Не интерактивная установка

Из командной строки

 msiexec /i FreeCAD<version>.msi

установка может быть начата программно. Дополнительные параметры могут быть переданы в конце командной строки, например

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

Ограниченный интерфейс пользователя

Величину пользовательского вмешательства, разрешенного установщиком, можно контролировать с помощью параметров /q:

  • /qn - без интерфейса
  • /qb - основной интерфейс - только маленький диалог прогресса с кнопкой Отмена
  • /qb! - как /qb, но скрыть кнопку Отмена
  • /qr - уменьшенный интерфейс - отображать все диалоги, которые не требуют взаимодействия с пользователем (пропустить все модальные диалоги)
  • /qn+ - как /qn, но отобразить диалог "Завершено" по окончании
  • /qb+ - как /qb, но отобразить диалог "Завершено" по окончании

Целевая папка

Параметр TARGETDIR определяет корневую папку для установки FreeCAD. Например, для установки на отдельный диск, может быть указано

TARGETDIR=R:\FreeCAD25

По умолчанию TARGETDIR имеет значение [WindowsVolume\Programm Files\]FreeCAD<version>.

Установка для всех пользователей

Добавление

ALLUSERS=1

приводит к установке для всех пользователей. По умолчанию, не интерактивная установка (/i) устанавливает пакет только для текущего пользователя(который выполняет установку), а интерактивная установка предлагает диалог со значением по умолчанию "для всех пользователей", если пользователь, выполняющий установку, имеет достаточно привилегий.

Выбор функций

Некоторые из параметров позволяют выбрать функции при установке, переустановке или удалении. Перечень функций для установки FreeCAD

  • DefaultFeature - установить программное обеспечение и основные библиотеки
  • Documentation - установить документацию
  • Source code - установить исходники
  • ... ToDo

Кроме того, ALL указывает все функции. Все функции зависят от DefaultFeature, поэтому при установке любой функции автоматически устанавливается и функция по умолчанию. Следующие свойства управляют функциями, которые будут установлены или удалены

  • ADDLOCAL - список функций, которые будут установлены на локальном компьютере
  • REMOVE - список функций, которые будут удалены с локального компьютера
  • ADDDEFAULT - список функций, добавленных с конфигурацией по умолчанию (локально для всех функций FreeCAD)
  • REINSTALL - список функций, подлежащих переустановке / восстановлению
  • ADVERTISE - список функций, для которых необходимо выполнить рекламную установку

Есть несколько дополнительных свойств; для деталей см. документацию MSDN.

С этими опциями, добавив

ADDLOCAL=Extensions

устанавливается сам интерпретатор и регистрируются расширения, но больше ничего не устанавливается.

Удаление

С

msiexec /x FreeCAD<version>.msi

FreeCAD может быть удален. Для удаления нет необходимости иметь файл MSI; как вариант могут быть указаны пакет или код продукта. Вы можете найти код продукта, просмотрев свойства ярлыка Uninstall, который 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 был деинсталлирован, если компьютер выходит за рамки политики.

Распространение групповой политики обычно занимает некоторое время - для надежного развертывания пакета все компьютеры должны быть перезагружены.

Установка в Linux с использованием Crossover Office

Вы можете установить Windows-версию FreeCAD в системе Linux, используя CXOffice 5.0.1 . Запустите msiexec из командной строки CXOffice. Предполагается что установочный пакет находится в каталоге «software» на диске «Y:»:

msiexec / i Y: \\ software \\ FreeCAD <версия> .msi

FreeCAD работает, но сообщается, что OpenGL дисплей не работает, как и другие программы, работающие под Wine, то есть Google SketchUp.

Установка в Unix/Linux

Установка FreeCAD на наиболее известных системах linux теперь поддерживается сообществом, и FreeCAD должен быть прямо доступен через менеджер пакетов вашего дистрибутива. Команда FreeCAD так же предоставляет множество "официальных" пакетов при выпуске новых версий, и множество экспериментальных репозиториев PPA для тестирование возможностей переднего края.

Когда Вы установили FreeCAD, пора начинать работу!

Установка на системы Debian/Ubuntu

Многие дистрибутивы Linux базируются на Ubuntu и используют их репозитории. Кроме официальных вариантов (Kubuntu, Lubuntu и Xubuntu), существуют неофициальные дистрибутивы, такие как Mnint, Voyager и другие. Приведенные ниже опции установки должны быть совместимыми с этими системами.

Официальный репозиторий Ubuntu

FreeCAD доступен из репозиториев Ubuntu и может быть установлен через Software Center либо следующей командой из терминала:

sudo apt-get install freecad

Важное примечание: Вероятно, стабильная версия уже устарела и не имеет последних возможностей. Для получения последней версии используйте указанные ниже опции Personal Package Archive (PPA).

Стабильный PPA с графическим интерфейсом

Чтобы установить FreeCAD с помощью PPA из графического интерфейса, пожалуйста, следуйте этим инструкциям. Сообщество FreeCAD предоставляет PPA repository on Launchpad с последней стабильной версией FreeCAD.

Требуется добавить в системные источники программ (Software Sources) следующие PPA. Для этого перейдите к Центр программ Ubuntu -> Изменить -> Источники программ -> Прочее программное обеспечение. Выберите добавить вставьте скопированный ниже код:

ppa:freecad-maintainers/freecad-stable

При запросе, обновите ваши источники программ. Теперь вы можете найти и установить последнюю стабильную версию FreeCAD в Центре программ Ubuntu.

Стабильный PPA через консоль

Наберите (или скопируйте и вставьте) эти команды в консоли для добавления PPA:


При использовании "stable" PPA

sudo add-apt-repository ppa:freecad-maintainers/freecad-stable

Не забудьте получить обновлённый список пакетов:

sudo apt-get update

Обновление синхронизирует ваш список доступных пакетов с серверами.

Затем, установите FreeCAD и документацию к нему:

sudo apt-get install freecad freecad-doc && sudo apt-get upgrade

Обновление загружает и устанавливает новейшие пакеты версий установленных программ. Он будет применяться ко всем программам, установленным на вашем компьютере.

Выполните эту команду, чтобы открыть стабильную версию FreeCAD:

freecad

Ежедневный PPA через консоль

Если вы хотите установить последнюю нестабильную версию FreeCAD, пожалуйста, используйте PPA с именем freecad-daily " 'репозиторий PPA на Launchpad. Таким образом, вы можете получить доступ к передовому краю разработки FreeCAD. Этот PPA автоматически компилируется ежедневно из главной ветки официального репозитория FreeCAD. Обычно он содержит многочисленные исправления ошибок и обновления функций.

Для ежедневного PPA:

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

You can then update to the latest daily at any time with:

sudo apt-get update
sudo apt-get install freecad-daily

Выполните эту команду для открытия ежедневной сборки FreeCAD:

freecad-daily

Debian другие базирующиеся на нём системы

Начиная с Debian Lenny, FreeCAD доступен прямо из программных репозиториев Debian и может быть установлен через synaptic или просто через:

sudo apt-get install freecad

OpenSUSE

FreeCAD обычно устанавливается через:

zypper install FreeCAD

Gentoo

FreeCAD может быть скомпилирован/установлен просто вызовом:

emerge freecad

Fedora

FreeCAD выл включён в официальные пакеты начиная с Fedora 20. Он может быть установлен из командной строки:

sudo dnf install freecad

Для предыдущих выпусков Fedora:

sudo yum install freecad

Также может быть использован менеджер пакетов с графическим интерфейсом пользователя. Выполните в менеджере пакетов поиск "

"freecad".

Версия пакета официального релиза как правило сильно отстает от релизов FreeCAD. Package: freecad показывает версии, включенные в репозитории Fedora с течением времени и версии.

Более свежие версии можно получить, загрузив один из .AppImage релизов из репозитория github. Они отлично работают на Fedora.

Если вы хотите быть в курсе самых последних ежедневных сборок, FreeCAD также доступен на coprЧтобы установить сборку оттуда введите в терминале:

sudo dnf copr enable @freecad/nightly
sudo dnf install freecad

Это оставляет copr хранилище активным, так что

sudo dnf upgrade

или эквивалентная команда, обновится до последней сборки FreeCAD вместе с обновлениями из любых других активных репозиториев. Если вы хотите что-то более стабильное, вы можете отключить @freecad/nightly снова после первоначальной установки. copr репозиторий сохраняет только сборки за последние 2 недели. Это не подходит, если вы хотите выбрать более старую конкретную версию.

Инструкции также доступны на соберите FreeCAD самостоятельно, включая скрипт, специально предназначенный для Fedora. С небольшим изменением, для извлечения конкретного коммита из git, любая версия начиная с FreeCAD 0.15 может быть построена на любом дистрибутиве начиная с Fedora 21.

Arch

Установка FreeCAD в Arch Linux и его производных (например, Manjaro):

pacman -S freecad

'Примечание' : с января 2019 года FreeCAD доступен только через AUR

pacman -S freecad

Другие

Если Вы обнаружите, что Ваша система использует FreeCAD, но не описана на этой странице, пожалуйста сообщите нам на форум!

В сети доступны многие альтернативные, неофициальные пакеты FreeCAD, например для систем вроде slackware или fedora. Поиск в сети быстро даст Вам какие-нибудь результаты.

Ручная установка на системах, основанных на .deb

Если по каким-то причинам Вы не можете использовать вышеуказанные методы, Вы всегда можете загрузить один из пакетов .deb, доступных на странице Загрузки page.
Linux.png Ubuntu 32/64bit AppImage-logo.png AppImage 64bit


Загрузив файл .deb соответственно версии Вашей системы, если у Вас используется установочный пакет Gdebi (обычно это так), Вам нужно перейти в место загрузки файла и сделать двойной щелчок на нём. Установочные зависимости будут учтены пакетным менеджером системы автоматически. Или Вы можете установить его из терминала, перейдя к месту загрузки файла и набрав:

sudo dpkg -i Name_of_your_FreeCAD_package.deb

изменив Name_of_your_FreeCAD_package.deb на имя загруженного файла.

После установки FreeCAD икона запуска будет добавлена в секцию "Графика" ("Graphic") стартового меню.

Установка на других системах Linux/Unix

Многие распространенные дистрибутивы Linux теперь включают в себя скомпилированный FreeCAD как часть стандартных пакетов. Он часто устаревший, но хорошая стартовая точка. Проверьте стандартные менеджеры пакетов для вашей системы. С помощью одного из следующих (частичных) списков команд можно установить официальную версию FreeCAD для вашего дистрибутива из терминала. Для этого вероятно потребуются права администратора.

apt-get install freecad
dnf install freecad
emerge freecad
slackpkg install freecad
yum install freecad
zypper install freecad

Имя пакета чувствительно к регистру, поэтому попробуйте `FreeCAD`, а также` freecad`. Если это не работает для вас, либо из-за того, что у вашего менеджера пакетов нет предварительно скомпилированной версии FreeCAD, либо из-за того, что доступная версия устарела для ваших нужд, вы можете попробовать загрузить один из .AppImage релизов из репозитория github. Они работают на большинстве 64-битных дистрибутивов Linux без какой-либо специальной установки. Просто убедитесь, что загруженный файл помечен как исполняемый, а затем запустите его.

К сожалению, на сегодня для других систем Linux/Unix собранных пакетов нет, так что вы должны собрать FreeCAD самостоятельно.


Установка версии для Windows на Linux

Смотрите страницу Установка на Windows.

Установка в Mac OS

FreeCAD можно установить в Mac OS X одним шагом, используя программу Установщик.

Mac.png MacOS 10.11 El Capitan 64-bit (sha256)


На этой странице описано использование и функции установщика FreeCAD. Есть также инструкция по удалению. После установки вы можете начать работать!

Простая установка

Установщик FreeCAD предоставляется в виде пакета приложения (.app), помещенного в файл образа.

Вы можете загрузить последнюю версию установщика со страницы Download. После загрузки файла просто смонтируйте образ диска, затем перетащите его в папку «Приложение» или в папку по вашему выбору.

Mac installer 1.png

Вот и все. Просто нажмите на приложение, чтобы запустить FreeCAD. Если у вас появляется сообщение «FreeCAD не может быть запущен, так как его разработчик неизвестен». Откройте папку (Приложение) и щелкните правой кнопкой мыши на приложении, затем нажмите «Открыть» и «Подтвердить», чтобы открыть приложение.


Удаление

В настоящее время для FreeCAD нет деинсталятора. Чтобы полностью удалить FreeCAD и все установленные компоненты, перетащите следующие файлы и папки в корзину:

  • В /Приложения:
    • FreeCAD

Больше ничего не требуется.

Обзор FreeCAD

Введение

FreeCAD - это приложение САПР для параметрического моделирования. Его в первую очередь создавали для машиностроительного проектирования, однако оно также поддерживает и иные варианты использования в случаях, когда нужно моделировать 3D объекты с заданной точностью и контролем над историей моделирования.

FreeCAD все еще находится в ранней стадии разработки, так что, хотя он уже предлагает большой (и растущий) список возможностей, многое, в сравнении с коммерческими решениями, по-прежнему отсутствует, и Вы вряд ли сочтёте его достаточно разработанным для использования в производстве. Тем не менее, у нас есть быстрорастущее сообщество увлеченных пользователей, и вы можете найти множество примеров качественных проектов, разработанных с использованием FreeCAD.

Как и все проекты с открытым кодом, проект FreeCAD не является односторонней работой, предоставленной его разработчиками. Он во многом зависит от роста своего сообщества, усиления возможностей и стабилизации кода (исправления ошибок). Так что не забывайте об этом, используя FreeCAD, если он вам нравится, то вы можете прямо вмешаться и помочь FreeCAD!

Установка

Для начала скачайте и установите FreeCAD. Смотрите информацию о текущей версии и последних обновлениях на странице загрузки, и инструкцию по установке на соответствующей странице. Имеются готовые пакеты установки на Windows (.msi), Ubuntu и Debian (.deb), openSUSE (.rpm) и Mac OSX. FreeCAD доступен в менеджерах пакетов множества других дистрибутивов Linux. Есть и исполняемый файл AppImage, который пригоден для запуска на большинстве современных 64-битных систем Linux. Поскольку у FreeCAD открытые исходные коды, Вы так же можете взять исходные коды и скомпилировать его самостоятельно.

Описание FreeCAD

FreeCAD interface.png
  1. Трёхмерный вид, показывающий содержимое Вашего документа
  2. Древо проекта, который показывает иерархию и историю конструирования всех объектов в вашем документе
  3. Редактор свойств, позволяющий просматривать и изменять параметры выбранных объектов
  4. Окно отчётов, где FreeCAD печатает сообщения, предупреждения и ошибки
  5. Консоль python, где печатаются все команды, выполняемые FreeCAD, и где можно ввести код python
  6. Переключатель верстаков, где Вы можете выбрать активный верстак

Основная концепция интерфейса FreeCAD в разделении её на верстаки. Верстаки представляют собой набор инструментов, приспособленных для отдельной задачи, такой как работа с сетями, или черчение двумерных объектов, или эскизов с направляющими. Текущий верстак можно переключить с помощью селектора (6). Есть возможность настроить инструменты каждого верстака, добавить их из другого верстака или даже создать самим, которые мы называем макросы. Есть так же универсальный верстак, который предлагает наиболее часто используемые инструменты из остальных рабочих столов, который называется полное рабочее окружение (complete workbench).

При первом старте Вам будет показан центр запуска FreeCAD. Вот так он выглядит в версии 0.16:

Startcenter0.17.ru.jpg

Для FreeCAD 0.17 гляньте этот скриншот Центра запуска.

Центр запуска позволяет быстро переключиться на один из наиболее часто используемых верстаков, открыть один из последних файлов, или посмотреть последние новости из мира FreeCAD. Рабочий стол по умолчанию можно изменить в настройках.

Навигация в 3D пространстве

В FreeCAD есть несколько режимов навигации, которые меняют способ использования мыши для взаимодействия с объектами в трёхмерном окне и сам вид. Один из них сделан под тачпады, где средняя кнопка не используется. Нижеследующая таблица показывает режим по умолчанию, называемый CAD' (Можно быстро сменить текущий режим навигации правым кликом на пустом месте трёхмерного вида):

Выбор Сдвиг Масштаб Вращать
Исходный метод
Вращать
Альтернативный метод
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png Rotate cursor.png
Mouse LMB.svg Mouse MMB hold.svg Mouse MMB rotate.svg Mouse MMB+LMB hold.svg Mouse MMB+RMB hold.svg
Нажмите левую кнопку мыши над объектом, который вы хотите выбрать.

Нажатием Ctrl можно выбрать несколько объектов.

Удерживая среднюю кнопку мыши, двигайте указатель. Используем колёсико мыши для приближения и отдаления.

Кликая средней кнопкой вид центрируется по положению курсора.

Удерживая среднюю кнопку мыши, нажмите и удерживайте левую кнопку мыши, затем двигайте указатель.

Положение курсора во время нажатия средней кнопки мыши определяет центр вращения. Вращение работает как кручение шара вокруг своего центра. Если кнопки отпущены до остановки кнопки мыши, если так настроено, вид продолжает крутиться.

Двойной клик средней кнопкой мыши устанавливает новый центр вращения.

Удерживая среднюю кнопку мыши, нажмите и удерживайте правую кнопку мыши, затем двигайте указатель.

При этом методе средняя кнопка мыши может быть отпущена после того как правая кнопка осталась нажатой.

Пользователи, использующие мышь правой рукой могут счесть этот метод проще исходного.

Ctrl+Mouse RMB.svg Ctrl+Shift+Mouse RMB.svg Shift+Mouse RMB.svg
Режим сдвига: удерживая кнопку Ctrl, один раз нажимаем правую кнопку мыши, затем двигаем указатель. introduced in version 0.17 Режим приближения: удерживая кнопки Ctrl и Shift, нажмите правую кнопку, и двигайте указатель. introduced in version 0.17 Режим вращения: удерживая кнопку Shift, нажмите правую кнопку, затем двигайте указатель. introduced in version 0.17


Вы так же можете выбрать несколько стандартных видов(вид сверху, спереди и т.д.) из меню Вид, на панели инструментов Вид, а также с помощью горячих клавиш (1, 2, и т.д.), а правым кликом на пустом месте трёхмерного вида Вы получите доступ к некоторым частым операциям, таким как выбор отдельного вида или нахождение объекта в Дереве проекта.

Первые шаги в FreeCAD

FreeCAD ориентирован на создание высокоточных трёхмерных моделей, сохранение четкого контроля над этими моделями (сохранение возможности вернуться назад по истории модели и изменить параметры), и при необходимости изготовить эти модели (через трёхзмерную печать, станками с ЧПУ или на заводе). Поэтому он отличается от некоторых других трёхмерных приложений, сделанных для других целей, таких как создание анимации или игр. Его кривая обучения может быть сложной для освоения, особенно если это ваш первый контакт с 3D-моделированием. Если Вы застряли на каком-то месте, не забудьте, что дружественное сообщество пользователей на форуме FreeCAD способно быстро подсказать Вам решение.

Верстак, с которого Вы начнёте использование FreeCAD, зависит от типа работы, которую Вам надо выполнить: если Вам нужно работать над механической моделью, или вообще над любым небольшим объектом, Вам возможно подойдёт верстак PartDesign. Если Вы работаете на плоскости, то переключитесь на верстак Draft, или верстак Sketcher, который позволяет работу с ограничениями. Если Вам требуется разработка здания по BIM, переключитесь на Arch Workbench. Для работы над плавательными средствами имеется специальный верстак Ship. А если Вы привыкли к OpenSCAD, попробуйте верстак OpenSCAD.

Верстак можно переключить в любой момент, а так же настроить ваш верстак и добавить инструменты с других верстаков.

Работа с верстаками PartDesign и Sketcher

Верстак PartDesign спроектирован для создания сложных объектов, начиная с простых форм и добавляя и удаляя элементы (которые мы называем "features"), пока Вы не получите итоговый объект. Все элементы, которые Вы добавите во время моделирования, сохраняются в отдельном виде, называемом древом проекта, который так же содержит другие объекты вашего документа. Объект PartDesign можно понимать как последовательность операций, применяемых к результатам предыдущих, создавая одну большую цепочку. В древе проекта виден финальный объект, но Вы можете раскрыть его и восстановить все предшествующие стадии и изменить любые их параметры, которые автоматических обновят финальный объект.

Верстак PartDesign широко использует другой верстак, Sketcher. Он позволяет рисовать плоские эскизы, которые определяются установкой ограничений (Constraints) к двумерной форме. Например, Вы можете нарисовать прямоугольник и установить размер стороны применением ограничений к одной из сторон. Размеры этой стороны теперь могут быть изменены лишь при изменении ограничений.

Эти двумерные формы, созданные в верстаке эскизов, широко используются в верстаке PartDesign, например, для создания трёхмерных объёмов или черчения полей на гранях вашего объекта, которые затем будут выдолблены из вашего объёма. Вот типичный рабочий процесс PartDesign:

  1. Создать новый эскиз
  2. Нарисовать замкнутую фигуру (необходимо убедиться, что все точки соединены)
  3. Закрыть эскиз
  4. Растянуть эскиз в твердое тело с помощью pad tool
  5. Выбрать одну грань твердого тела
  6. Создать второй эскиз (на этот раз он будет нарисован на выбранной грани)
  7. Нарисовать замкнутую фигуру
  8. Закрыть эскиз
  9. Создать карман из второго эскиза на первом объекте

Что создаст объект вроде этого:

Partdesign example.jpg

В любой момент Вы можете выделить оригинальный эскиз и изменить его или или изменить параметр выдавливания операции pad или pocket, что изменит итоговый проект.

Работа с верстаками Draft и Arch

Верстаки Draft и Arch действуют немного по-разному, хотя они следуют общим правилам для FreeCAD. Если коротко, Sketcher и PartDesign созданы в первую очередь для проектирования единых деталей, а Draft и Arch для работы с несколькими простыми объектами.

Верстак Draft предоставляет двумерные инструменты вроде тех, что можно найти в традиционных двумерных САПР вроде AutoCAD. Тем не менее двумерное черчение находится вне задач FreeCAD, и не ожидайте найти здесь полное множество инструментов, которые предлагают эти специализированные инструменты. Большинство инструментов верстака Draft работают не только на плоскости, но и в объёме, и получают пользу от специальных вспомогательных систем вроде выбора плоскости и привязки к объектам.

Верстак Arch добавляет FreeCAD инструмент BIM, позволяя создавать архитектурные модели через параметрические объекты. Верстак Arch зависит от других модулей, таких как Draft и Sketcher. Все инструменты Draft так же имеются в верстаке Arch, и большинство инструментов Arch используют вспомогательные системы Draft.

Типичный рабочий процесс с верстаками Arch и Draft может быть таким:

  1. Нарисовать набор лилий с помощью инструментаDraft Line
  2. Выбрать каждую линию и использовать инструмент Wall, чтобы создать стену на каждом из них
  3. Соединить стены, выбрав их и нажав на инструмент Arch Add
  4. Создать объект floor (пол), и поместить Ваши стены на него из древа проекта
  5. Создать объект building, и переместить ваш пол и в него из древа проекта
  6. Создать окно, нажав на инструмент Window, выбрать предустановки в его панели, затем нажать на поверхность стены
  7. Добавить размеры, сначала установив рабочую плоскость если необходимо, затем испольжуя инструмент Draft Dimension

В результате получится следующее:

Arch workflow example.jpg

Дальнейшее на странице Учебники (то же на английском).

Скрипты

Freecad, as an open source software, offers the possibility to supplement its workbenches with addons.

The Addon principle is based on the development of a workbench complement. Any user can develop a function that he or she deems to be missing for her/his own needs or, ultimately, for the community. With the forum, the user can request an opinion, help on the forum. It can share, or not, the object of its development according to copyright rules to define. Free to her/him. To develop, the user has available scripting functions.

There are two types of addons:

  1. Macros: short snippets of Python code that provide a new tool or functionality. Macros usually start as a way to simplify or automate the task of drawing or editing a particular object. If many of these macros are collected inside a directory, the entire directory may be distributed as a new workbench.
  2. External workbenches: collections of tools programmed in Python or C++ that extend FreeCAD in an important way. If a workbench is sufficiently developed and is well documented, it may be included as one of the base workbenches in FreeCAD. Under External workbenches, you'll find the principle and a list of existing library.

Scripting

И в заключение, один из самых мощных свойств FreeCAD это скриптовое окружение. Из встроенной консоли python (или из любого другого внешнего скрипта python) можно получить доступ почти ко всем частям FreeCAD, создание и изменение геометрии, изменение отображения объектов на экране, а также доступ и изменение интерфейса. Скрипты могут быть использованы в макросах, с помощью которых легко создавать свои команды.

Что нового?


Модель мыши FreeCAD состоит из команд для визуальной навигации в трёхмерном пространстве и взаимодействия с показываемыми объектами. FreeCAD поддерживает несколько моделей навигации с помощью мыши. Стиль навигации по умолчанию обозначается как "CAD Navigation," он очень простой и практичный, но FreeCAD так же предлагает альтернативные стили навигации, которые Вы можете выбрать по своим предпочтениям.

Навигация

Используемые для манипуляции объектами жесты мышью отличаются в зависимости от выбранного стиля навигации, выбранный стиль общий для всех верстаков.

Существует два способа изменить стиль навигации:

  • В Настройках, Правка → Параметры → Отображение → 3D Вид → 3D-навигация.
  • Правым кликом на пустом месте области пространственного вида и выбором Стили навигации →... контекстного меню.

Навигация CAD

Это стиль навигации по умолчанию и позволяет пользователю простейшее управление видом, не требуя использования клавиатуры, кроме как для множественного выделения.

Выбор Сдвиг Масштаб Вращать
Исходный метод
Вращать
Альтернативный метод
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png Rotate cursor.png
Mouse LMB.svg Mouse MMB hold.svg Mouse MMB rotate.svg Mouse MMB+LMB hold.svg Mouse MMB+RMB hold.svg
Нажмите левую кнопку мыши над объектом, который вы хотите выбрать.

Нажатием Ctrl можно выбрать несколько объектов.

Удерживая среднюю кнопку мыши, двигаем указатель. Используем колёсико мыши для приближения и отдаления.

Кликом средней кнопкой вид центрируется по положению курсора.

Удерживая среднюю кнопку мыши, нажмите и удерживайте левую кнопку мыши, затем двигайте указатель.

Положение курсора во время нажатия средней кнопки мыши определяет центр вращения. Вращение работает как кручение шара вокруг своего центра. Если кнопки отпущены до остановки кнопки мыши, если так настроено, вид продолжает крутиться.

Двойной клик средней кнопкой мыши устанавливает новый центр вращения.

Удерживая среднюю кнопку мыши, нажмите и удерживайте правую кнопку мыши, затем двигайте указатель.

При этом методе средняя кнопка мыши может быть отпущена после того как правая кнопка осталась нажатой.

Пользователи, использующие мышь правой рукой могут счесть этот метод проще исходного.

Ctrl+Mouse RMB.svg Ctrl+Shift+Mouse RMB.svg Shift+Mouse RMB.svg
Режим сдвига: удерживая кнопку Ctrl, один раз нажимаем правую кнопку мыши, затем двигаем указатель. introduced in version 0.17 Режим приближения: удерживая кнопки Ctrl и Shift, нажмите правую кнопку, и двигайте указатель. introduced in version 0.17 Режим вращения: удерживая кнопку Shift, нажмите правую кнопку, затем двигайте указатель. introduced in version 0.17


Навигация OpenInventor

При навигации в стиле OpenInventor. Для выделения объектов надо нажать кнопку CTRL.

Этот метод базируется на на Autodesk Inventor.

Выбор Сдвиг Масштаб Вращать
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png
Ctrl+Mouse LMB.svg Mouse MMB hold.svg Mouse MMB rotate.svg Mouse MMB+LMB hold.svg Mouse LMB hold.svg
Удерживая Ctrl, нажимаем левую кнопку мыши над объектом, который хотим выделить. Удерживая среднюю кнопку мыши, двигаем указатель. Используем колёсико мыши для приближения и отдаления.

Иначе, удерживая среднюю кнопку мыши, нажимаем и удерживаем её левую кнопку, затем двигаем указатель.

Удерживая левую кнопку мыши, двигаем указатель.


Навигация Blender

Стиль навигации Blender ориентируется на Blender. Ранее не было возможности сдвига только мышью, и требовалось нажимать кнопку SHIFT для сдвига вида. Это было изменено в 2016 году при добавке возможностей, теперь для сдвига можно нажать левую и правую кнопку мыши.

Выбор Сдвиг Масштаб Вращать
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png
Mouse LMB.svg Shift+Mouse MMB hold.svg Mouse LMB+RMB hold.svg Mouse MMB rotate.svg Mouse MMB hold.svg
Нажмите левую кнопку мыши над выделяемым объектом. Удерживайте Shift и среднюю кнопку мыши и двигайте объект.

Либо удерживайте левую и правую кнопки и перемещайтесь.

Используйте колёсико мыши для приближения и отдаления. Нажмите и тяните средней кнопкой мыши.


Навигация Touchpad

При включении навигации тачпадом, сдвиг, масштабирование и вращение вида требует вместе с тачпадом использования модифицирующих клавиш.

Выбор Сдвиг Масштаб Вращение
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png
Touchpad LB.svg Shift+Touchpad.svg PageUp, PageDown Alt+Touchpad.svg
Нажмите левую кнопку над объектом, который хотите выбрать. Удерживайте Shift и двигайте объект. Используйте PageUp и PageDown для приближения или отдаления. Удерживайте Alt и двигайте указатель.
Shift+Ctrl+Touchpad.svg Shift+Touchpad LB hold.svg
Иначе, удерживайте вместе Shift и Ctrl, нажмите левую кнопку мыши, и двигайте указатель. Иначе, удерживайте клавиши Shift стрелку влево, затем двигайте указатель.


Навигация Gesture

Этот стиль навигации был предложен в версии 0.16, и скроен для использования с точскрином и пером, однако пригоден и для использования с мышью.

Выбор Сдвиг Масштаб Вращение Tilt view
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png Rotate cursor.png
Mouse LMB.svg Mouse RMB hold.svg Mouse MMB rotate.svg Mouse LMB hold.svg Mouse LMB+RMB hold.svg
Нажмите левую кнопку мыши над объектом, который хотите выделить. Удерживайте правую кнопку мыши и тяните курсор для сдвига вида. Используйте колёсико мыши для масштабирования. Удерживайте левую кнопку мыши и тяните указатель.

В режиме Sketcher и некоторых других это действие заблокировано. Удерживайте Alt при нажатии кнопки мыши для перехода в режим вращения.

Чтобы установить точку фокуса камеры для вращения, кликните новую точку средней кнопкой мыши. Взамен, нацельте курсор в новую точку и нажмите кнопку H на клавиатуре.

Удерживайте левую и правую кнопку мыши и тяните указатель в сторону.
Touch Tap.svg Touch Two-Finger-Drag.svg Touch Tap-Hold-Drag.svg Touch Pinch.svg Touch One-Finger-Drag.svg Touch Rotate.svg
Щелкните для выбора. Тяните двумя пальцами.

Иначе, удерживайте щёлкните и удержите, потом тяните. Это симулирует сдвиг правой кнопкой мыши.

Сдвиньте пальцы для масштабирования (т.е. потяните два пальца к/от друг друга). Потяните одним пальцем для вращения.

Удерживайте вдобавок Alt в режиме Sketcher.

Вращайте воображаемую линию между двумя точками касания.

В версии v0.18 этот метод по умолчанию отключён. Для разрешения Правка → Параметры → Отображение, и снимите метку "Disable touchscreen tilt gesture".


Навигация MayaGesture

При навигации типа MayaGesture, перемещения видов требуют нажатия ALT с кнопкой мыши, поэтому для него требуется трехкнопочная мышь. Взамен можно использовать жесты из режима Gesture.

Выбор Сдвиг Масштаб Вращать
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png
Mouse LMB.svg Alt+Mouse MMB hold.svg Alt+Mouse RMB hold.svg Mouse MMB rotate.svg Alt+Mouse LMB hold.svg
Нажмите левую кнопку мыши над выделяемым объектом. Удерживая Alt и среднюю кнопку мыши, двигайте указатель. Удерживая Alt и правую кнопку мыши, двигайте указатель.

Иначе, используйте для приближения и отдаления колёсико мыши.

Удерживая Alt и левую кнопку мыши, двигайте указатель.


Навигация Revit

Этот стиль был предложен в версии 0.18.

Выбор Сдвиг Масштаб Вращать
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png
Mouse LMB.svg Mouse MMB hold.svg Mouse LMB+RMB hold.svg Mouse MMB rotate.svg Shift+Mouse MMB hold.svg Mouse MMB+RMB hold.svg


Нажать левую кнопку мыши над выделяемым объектом. Удерживайте среднюю кнопку мыши и двигайте указатель.

Иначе, удерживая левую и правую кнопку мыши, двигайте указатель.

Используйте для приближения и отдаления колёсико мыши. Удерживая Shift и среднюю кнопку мыши, двигайте указатель.

Иначе, удерживая среднюю кнопку мыши, нажмите и удерживайте правую кнопку, затем двигайте указатель.


OpenCascade

Этот стиль был предложен в версии 0.18.

Выбор Сдвиг Масштаб Вращать
Hand cursor.png Pan cursor.png Zoom cursor.png Rotate cursor.png
Mouse LMB.svg Ctrl+Mouse MMB hold.svg Mouse MMB hold.svg Mouse MMB rotate.svg Ctrl+Mouse LMB hold.svg Ctrl+Mouse RMB hold.svg


Нажать левую кнопку мыши над выделяемым объектом. Удерживайте среднюю кнопку мыши и двигайте указатель. Используйте колёсико мыши для приближения и отдаления.

Иначе, удерживая Ctrl и левую кнопку мыши, двигайте указатель.

Удерживая Ctrl и правую кнопку мыши, двигайте указатель.


Выбор объектов

Простой Выбор

Объекты могут быть выбраны щелчком левой клавиши мыши, нажав на объект в окне 3D просмотра или выбрав его в дереве.

Предварительный выбор

Также существует механизм Предвыбор, который подсвечивает объект и отображает информацию о них до выбора, уже при наведении указателя мыши на них. Если вам не нравится это поведение или у вас медленная машина, вы можете отключить предварительный выбор (preselection) в настройках.

Управление Объектами

FreeCAD предлагает манипуляторы которые могут быть использованы для изменения объектов или их внешнего вида.

Простой пример секущая плоскость которая может быть активирована в меню View → Clipping Plane.

Поддержка оборудования

FreeCAD так же поддерживает несколько 3d мышей.

Проблемы Mac OS X

В настоящее время имеется сообщение на форуме от пользователей Mac, что кнопка мыши и сочетание клавиш работают не так, как ожидается. К сожалению, ни один из наших разработчиков не использует Mac. Нам требуется помощь, чтобы определить, какие сочетания кнопок мыши и комбинации клавиш работают, чтобы мы смогли обновить текст на wiki.

Работа в FreeCAD

Структура документа FreeCAD

Screenshot treeview.jpg

Документ FreeCAD содержит все объекты проекта. Он может содержать группы, и предметы, сделанные с любого инструментария(workbench). Поэтому вы можете переключаться между инструментариями, и до сих пор работать на том же документе. Получившийся документ будет сохранён на диске при сохранении работы. В FreeCAD, вы также можете открывать несколько документов одновременно и открыть несколько видов одного и того же документа.

В документе объекты могут быть помещены в группы и им можно присвоить уникальные имена. Управлять группами, объектами и именами объектов осуществляется главным образом с помощью древовидного списка. Также это можно сделать, как и всё в FreeCAD, с помощью Python-интерпретатора. В древовидном списке, вы можете создавать группы, перемещать объекты в группы, удалять объекты или группы, кликнув правой клавишей на объект в древовидном списке, переименуйте объекты. Также можно переименовать объект выделив его в древовидном списке и нажав F2, также возможны другие комбинации в зависимости от текущего инструментария.

Объекты входящие в FreeCAD документ могут быть различных типов. Каждый инструментарий может создать свои собственные типы объектов, для примера Инструментарий полигионального моделирования создаёт объекты состоящие из полигонов, Инструментарий Деталей создает детали, Чертежный Инструменарий также создаёт детали, и.т.д.

Если есть по крайней мере один документ открытый в FreeCAD, всегда есть один и только один активный документ. Этот документ отображается в текущем окне 3D просмотра, это документ над которым вы сейчас работаете.

Приложения и интерфейс пользователя

Как почти все в FreeCAD, графический пользовательский интерфейс(GUI) отделен от основной части приложения(App). Также и с документами. Документы также состоят из двух частей: документ Приложение, содержащий ваши объекты, и документ как Вид, который содержит представление на экране наших объектов.

Думайте об этом как о двух местах, где определены ваши объекты. Их конструктивные параметры (это куб? конус? его размер?) хранятся в документе Приложении, а их графическое представление (отображать его в черных линиях? с синими гранями?) хранятся в части документ Вид. Зачем это сделано? Потому что FreeCAD может быть использован без графического интерфейса, например в других программах, и мы должны быть в состоянии управлять нашими объектами, даже если ничего не будет отображаться на экране.

Еще в части документа Вид содержатся объёмные виды. Один документ может иметь несколько открытых видов, так что вы можете просматривать ваш документ одновременно с нескольких точек зрения. Может быть вы хотели бы одновременно смотреть на ваш объект спереди и сверху? Тогда в вашем документе будет две части Вид документа. Создать новые виды или закрыть старые виды можно с помощью меню Вид или кликнув правой кнопкой мыши по закладке вида.

Написание сценариев

Документы легко могут быть созданы и изменены с помощью интепретатора Python. Например:

FreeCAD.ActiveDocument

Вернет текущий (активный) документ

FreeCAD.ActiveDocument.Blob

Даст доступ к объекту с именем "Blob" внутри вашего документа

FreeCADGui.ActiveDocument

Вернет вид-документ связаный с текущим документом

FreeCADGui.ActiveDocument.Blob

Получить доступ к графическому представлению (виду) объекта с именем Blob

FreeCADGui.ActiveDocument.ActiveView

Вернет текущий активный вид.

Настройка пользовательских предпочтений

Настройки FreeCAD расположены в меню Правка → Настройки.

FreeCAD функционально разделён на различные модули, каждый модуль отвечает за работу конкретного верстака. FreeCAD использует концепцию, называемую конечной загрузкой, которая означает, что компоненты загружаются только тогда, когда они необходимы. Вы могли заметить, что когда выбираете верстак на панели инструментов FreeCAD, в этот момент загружается верстак и все его компоненты. Это включает в себя и параметры настроек.

Без загруженных модулей у вас будет доступ к двум разделам конфигурации, отвечающие за основные настройки приложения и за настройки дисплея. Когда вы находитесь в определенном верстаке, настройки этого верстака отображаются в виде нового раздела, а форматы файлов, поддерживаемые верстаком, отображаются в виде новой вкладки в разделе Импорт-Экспорт.

Нажатие на кнопку Reset в левом нижнем углу экрана настроек установит «все» настройки FreeCAD в их значения по умолчанию.

Основные настройки

Этот раздел настроек имеет 6 вкладок:

Основная

На вкладке «Основная» вы можете указать следующее:

Имя Описание
Изменить язык Выберите язык пользовательского интерфейса FreeCAD
Размер списка последних файлов Укажите, сколько файлов должно быть указано в списке последних файлов.
Включить фон из повторяющегося узора Если этот флажок установлен, фон главного окна FreeCAD по умолчанию будет состоять из плиток этого изображения: Background.png
Этот параметр действует только в том случае, если в Таблица стилей / Нет таблицы стилей .
Изображение можно изменить, добавив папки Gui/Images в папку
%APPDATA%/FreeCAD (в Windows),
$HOME/.FreeCAD (в Linux) или
$HOME/Library/Preferences/FreeCAD (в MacOS).
Поместите туда файл с именем background.png и снимите флажок / установите этот флажок чтобы увидеть измененный файл.
Стиль интерфейса Выбор таблицы стилей. Таблицы стилей определяют, как выглядит пользовательский интерфейс FreeCAD.
Размер значков на панелях инструментов Выбор размера для значков панели инструментов
При запуске автоматически загружать верстак Выбор того, какой верстак будет использоваться сразу после запуска FeeCAD
Включение экрана-заставки при запуске Если этот флажок установлен, при запуске отображается заставка FreeCAD.
Изображение заставки можно изменить, добавив папки Gui/Images в папку %APPDATA%/FreeCAD (где %APPDATA% - пользовательская папка приложения FreeCAD вашей операционной системы). Поместите туда файл с именем splash_image.png и перезапустите FreeCAD, чтобы увидеть измененный экран-заставку.
Включить перенос слов Слова будут перенесены, когда они превысят доступное горизонтальное пространство в консоли Python. Эта консоль отображается с помощью меню Вид → Панели → Консоль Python.

This option only has an effect if in Style sheet/No style sheet is selected.

The image can be changed by adding the folders Gui/Images in the folder

%APPDATA%/FreeCAD (on Windows),

$HOME/.FreeCAD (on Linux) or

$HOME/Library/Preferences/FreeCAD (on MacOS).

Put there a file named background.png and uncheck/check this option to see the changed file. |- | Style sheet | Selection of a style sheet. The style sheets define how the user interface of FreeCAD looks. |- | Size of toolbar icons | Selection of the size for the toolbar icons |- | Auto load module after start up | Selection what workbench will be used directly after starting FreeCAD |- | Enable splash screen at start up | If checked, the splash screen of FreeCAD is shown when starting.

The splash screen image can be changed by adding the folders Gui/Images in the folder %APPDATA%/FreeCAD (where %APPDATA% is the the user-specific application folder of FreeCAD of your operating system). Put there a file named splash_image.png and restart FreeCAD to see the changed splash screen. |- | Enable word wrap | Words will be wrapped when they exceed the available horizontal space in the Python console. This console is shown using the menu View → Panels → Python console. |}

Preference General Tab 01 ru.png

Документ

На вкладке «Документ» вы можете указать следующее:

Name Описание
Создавать новый документ при запуске Если отмечено, FreeCAD создаст новый документ при запуске
Уровень сжатия сохраняемого документа Спецификация уровня сжатия для файлов FCStd. Файлы FCStd являются сжатыми файлами ZIP. Поэтому вы можете переименовать их суффикс .FCStd в .zip и открыть их с помощью программы ZIP-архива.
Отмены/Повторы Если этот флажок установлен, все изменения в документах сохраняются, чтобы их можно было отменить/повторить.
Максимум шагов отмен/повторов Укажите, сколько шагов Отмена/Повтор нужно записать
Запуск автоматического восстановления при запуске Если файл восстановления доступен, FreeCAD автоматически запустит восстановление файла при запуске. Таким образом, файлы могут быть восстановлены в случае сбоя.
Автосохранение каждые Укажите, как часто записывается файл восстановления.
Сохранить миниатюру в файл проекта при сохранении документа Если этот флажок установлен, при сохранении документа также будет сохранена миниатюра. Например, миниатюра будет отображаться в списке последних файлов в Верстаке Start.
Добавить логотип программы в генерируемую миниатюру Если установлен этот флажок, логотип программы FreeCAD FreeCAD-logo.svg будет добавлен к миниатюре. Этот параметр действует только в том случае, если используется Сохранить миниатюру в файл проекта при сохранении документа.
Максимальное количество файлов резервных копий, при пересохранении документа Если этот флажок установлен, файлы резервных копий будут сохраняться при сохранении документа. Вы можете указать количество сохраняемых файлов резервных копий. Они содержат ранее сохраненную версию документа. Первый файл резервной копии будет иметь суффикс файла .FCStd1, второй .FCStd2 и т.д.
Разрешить идентичные метки объектов в одном документе Если флажок установлен, объекты могут иметь одинаковую метку/имя. Например, разные части или элементы могут иметь одинаковое имя в одном и том же документе.
Имя автора Все документы, которые будут созданы, получат указанное имя автора. Оставьте поле автора пустым для анонимного автора. Если опция Устанавливать при сохранении отмечена, поле Last updated by будет установлено для указанного автора при сохранении файла. Это поле можно просмотреть с помощью меню Файл → Информация о проекте.
Компания Все документы, которые будут созданы, получат указанное название компании
Лицензия по умолчанию Выбор лицензии по умолчанию для новых документов. Для предопределенной лицензии URL-адрес лицензии будет автоматически установлен соответствующим образом. Выберите «Другое» для собственной или специальной лицензии.
URL адрес лицензии Указание URL-адреса, описывающего лицензию, выбранного в Лицензия по умолчанию
Preference General Tab 02 ru.png

Редактор кода

Настройки предпочтений редактора влияют на поведение редактора макросов. Этот редактор можно открыть с помощью меню Макрос → Макросы... → Редактировать/Создать.
Примечание: настройки цвета и шрифта также влияют на Python консоль. Эта консоль отображается с помощью меню Вид→Панели→Консоль Python.

The color and font settings also affect the Python console. This console is shown using the menu View → Panels → Python console.

На вкладке «Редактор» вы можете указать следующее:

Name Описание
Подсветка синтаксиса Выбор типа кода. Настройки цвета и шрифта будут применены к выбранному типу. Результат можно увидеть в поле «Предпросмотр».
Шрифт Выбор типа шрифта, который должен использоваться для выбранного типа кода
Размер Выбор размера шрифта, который должен использоваться для выбранного типа кода
Показывать номера строк Если флажок установлен, строки кода будут пронумерованы
Шаг табуляции Определение шага табулятора (количество пробелов). Если, например, установлено значение «6», при нажатии Tab будет выполнен переход к символу 7, 13, 19 и т.д., в зависимости от текущей позиции курсора. Этот параметр используется только в том случае, если выбран Символы табуляции.
Размер отступа Укажите, сколько пробелов будет вставлено при нажатии Tab. Этот параметр используется только в том случае, если выбран Заменять на пробелы.
Символы табуляции Если выбрано, нажатие Tab вставит табулятор с растром, определяемым Шаг табуляции
Заменять на пробелы Если выбрано, нажатие Tab вставит количество пробелов, определяемых Размер отступа
Preference General Tab 03 ru.png

Просмотр отчета

На вкладке «Просмотр отчёта» вы можете указать следующее:

Name Описание
Выводить информационные сообщения (log) Если установлен этот флажок, также будут отображаться информационные сообщения. Они будут выведены на панель Отчет цветом, установленным в Журнал (logs). Эта панель активируется с помощью меню Вид → Панели → Отчет.
Выводить предупреждения (warnings) Если флажок установлен, предупреждения будут отображаться. Они будут выведены на панель Отчет цветом, установленным в Предупреждения (warnings).
Выводить сообщения об ошибках (errors) Если флажок установлен, то будут отображаться сообщения об ошибках. Они будут выведены на панель Отчет цветом, установленным в Ошибки (errors)
Обычные сообщения Задание цвета шрифта для обычных сообщений на панели Отчет.
Журнал (log) Задание цвета шрифта для сообщений журнала на панели Отчет.
Предупреждения (warnings) Задание цвета шрифта для предупреждающих сообщений на панели Отчет.
Ошибки (errors) Задание цвета шрифта для сообщений об ошибках на панели Отчет.
Перенаправить внутренний вывод Python в отчёт Если этот флажок установлен, внутренний вывод Python будет перенаправлен с консоли Python на панель Отчет. Консоль Python отображается с помощью меню Вид → Панели → Консоль Python
Перенаправить внутренние ошибки Python в отчёт Если этот флажок установлен, сообщения об ошибках Python будут перенаправляться из консоли Python на панель Отчет.

In the Output tab you can specify the following:

Name Description
Record log messages If checked, also log messages will be recorded. They will be output in the Report view panel with the color set in Log messages. This panel is shown using the menu View → Panels → Report view.
Record warnings If checked, warnings will be recorded. They will be output in the Report view panel with the color set in Warnings.
Record error messages If checked, error messages will be recorded. They will be output in the Report view panel with the color set in Errors
Normal messages Specification of the font color for normal messages in the Report view panel.
Log messages Specification of the font color for log messages in the Report view panel.
Warnings Specification of the font color for warning messages in the Report view panel.
Errors Specification of the font color for error messages in the Report view panel.
Redirect internal Python output to report view If checked, internal Python output will be redirected from the Python console to the Report view panel. The Python console is shown using the menu View → Panels → Python console
Redirect internal Python errors to report view If checked, internal Python error messages will be redirected from the Python console to the Report view panel.
Preference General Tab 04 ru.png

Макрос

На вкладке «Макрос» вы можете указать следующее:

Name Описание
Запуск макросов в локальном окружении Если флажок установлен, переменные, определенные макросами, создаются как локальные переменные, в противном случае они создаются как глобальные переменные Python
Куда записывать макросы Указание пути к макросам
Запись команд графического интерфейса Если флажок установлен, записанные макросы также будет содержать команды интерфейса пользователя
Записывать как комментарий Если этот флажок установлен, записанные макросы также будет содержать команды интерфейса пользователя, но в виде комментариев. Это полезно, если вы не хотите выполнять видимые действия при запуске макроса, а видеть, что можно сделать визуально.
Показать команды скрипта в консоли Python Если этот флажок установлен, команды, выполняемые макросами, отображаются в консоли Python. Эта консоль отображается с помощью меню Вид → Панели → Консоль Python.

In the Macro tab you can specify the following:

Name Description
Run macros in local environment If checked, variables defined by macros are created as local variables, otherwise as global Python variable
Macro path Specification of a path to macro files
Recording GUI commands If checked, recorded macros will also contain user interface commands
Record as comment If checked, recorded macros will also contain user interface commands but as comments. This is useful if you don't want to execute visible actions when running the macro but to see what could be done visibly.
Show script commands in python console If checked, the commands executed by the macro scripts are shown in the Python console. This console is shown using the menu View → Panels → Python console.
Preference General Tab 05 ru.png

Единицы измерения

This tab configures how Units are shown.

На вкладке «Единицы измерения» вы можете указать следующее:

Name Описание
Пользовательская система Выбор системы единиц, которая должна использоваться для всех частей FreeCAD
Количество десятичных знаков Количество десятичных знаков, которые должны быть указаны для чисел и размеров в FreeCAD
Минимальный часть дюйма Минимальная часть дюйма, которая должна отображаться. Этот параметр доступен только в том случае, если используется система измерения 'Строительные US (Футы-дюймы/кв. футы/куб. футы)' .
Preference General Tab 06 ru.png

Настройки дисплея(Отображение)

Этот раздел настроек имеет до 3 вкладок:

Трехмерный вид

Параметры импорта-экспорта влияют на то, как файлы импортируются и экспортируются во FreeCAD и из него. Обратите внимание, что диалоговое окно настроек «Импорт-экспорт» предлагает параметры типа файла для большинства верстаков, но не все верстаки могут импортировать / экспортировать все типы файлов.

На вкладке «Трехмерный вид» вы можете указать следующее:

Имя Описание
Показать систему координат в углу Если флажок установлен, основная система координат всегда будет отображаться в правом нижнем углу в открытых файлах
Показать счетчик кадров в секунду Если этот флажок установлен, время, необходимое для последней операции, и полученная частота кадров [1] всегда будут отображаться в нижнем левом углу в открытых файлах.
Показать навигационный куб Если установлен этот флажок, навигационный куб всегда будет отображаться в выбранном углу в открытых файлах
Использовать объект вершинного буфера (Vertex Buffer) OpenGL Если флажок установлен, будут использоваться объекты буфера вершин (VBO). VBO - это функция OpenGL, которая предоставляет методы для загрузки данных вершин (положение, вектор нормали, цвет и т.д.) на видеоустройство. VBO обеспечивает существенный выигрыш в производительности, потому что данные находятся в памяти видеоустройства, а не в системной памяти, и поэтому они могут отображаться непосредственно видеоустройством. Для получения дополнительной информации см. эту веб-страницу.
Включить анимацию Если установлен этот флажок, вращения можно анимировать. Например, если используется набор Трехмерная навигация CAD и мышь перемещается, когда колесо прокрутки и правая кнопка мыши нажаты, детали вращаются. Если удерживать мышь во время отпускания, например, правая кнопка мыши, вращение будет продолжено как анимация. Для завершения анимации щелкните левой кнопкой мыши.
Трехмерная навигация Выбор набора настроек навигации. Чтобы увидеть, что определяет каждый набор, выберите набор и нажмите кнопку Мышь....
Вращение Выбор стиля вращения. При просмотре детали в плоскости xy, находящейся в режиме вращения 3D-навигации, разница в следующем: если выбран 'Трекбол' , перемещение мыши по горизонтали будет вращать деталь вокруг оси y, если выбран ' «Поворотный круг» , деталь будет вращаться вокруг оси z.
Сглаживание Выбор используемого типа Multisample сглаживания
Ориентация камеры нового документа Выбор ориентации камеры для новых документов
Зум туда, где мышь Если установлен этот флажок, операции масштабирования будут выполняться в позиции указателя мыши. В противном случае операции масштабирования будут выполняться в центре текущего вида. Zoom step определяет коэффициент масштабирования. Шаг масштабирования «1» означает коэффициент 7,5 для каждого шага масштабирования.
Инвертировать зум Если флажок установлен, направление операций масштабирования будет инвертировано.
Отключить жест наклона сенсорного экрана Если установлен этот флажок, жест наклона будет отключен для масштабирования с увеличением (двумя пальцами). Это влияет только на набор Трехмерная навигация Gesture.
Перенести к курсору Если этот флажок установлен, для поворотов в 3D будет использоваться текущая позиция курсора в качестве центра поворота. В противном случае всегда будет использоваться центр экрана.
Размер метки Выбор размера вершины (точки) в верстаке Sketcher
Расстояние между глаз для стерео режима Спецификация расстояния между глазами, используемого для стереопроекции. Указанное значение является коэффициентом, который будет умножен на размер ограничивающего прямоугольника трехмерного объекта, который отображается в данный момент.
Включить цвет подсветки Если флажок установлен, подсветка включена с заданным цветом
Интенсивность подсветки Спецификация интенсивности подсветки. Этот параметр включается только в том случае, если отмечен Включить цвет подсветки.
Тип камеры Выбор типа проекции камеры.
Если выбран Прорисовка перспективной проекции, объекты будут отображаться в перспективной проекции.
Если выбран Прорисовка ортогональной проекции, объекты будут проецироваться в оротогональной проекции.

|}

Preference Display Tab 01 ru.png

Цвета

FreeCAD поддерживает множество форматов файлов. Для следующих форматов файлов предлагается применить специальные настройки:

На вкладке «Цвета» вы можете указать следующее:

Параметр Описание
Включить подсвечивание при наведении курсора Если этот флажок установлен, предварительный выбор включен и будет выделен указанным цветом. Предварительный выбор означает, что, например, ребра в деталях будут выделены при наведении курсора на них, чтобы указать, что они могут быть выбраны.
Включить подсвечивание выделенного Если флажок установлен, подсветка выделения включена и для нее будет использоваться указанный цвет
Укажите радиус (пикс.) Устанавливает размер области для выбора элементов в трехмерном представлении. Большее значение облегчает выбор материала, но делает невозможным выбор некоторых мелких функций.
Один цвет Если выбрано, фон для деталей будет иметь выбранный цвет
Цветовой градиент Если выбрано, фон для деталей будет иметь выбранный градиент цвета
Средний цвет Доступно только если выбрано Цветовой градиент. Если этот флажок установлен, цветовой градиент получит выбранный цвет как средний цвет.
Объект редактируется Выбор цвета фона для объектов в виде дерева, которые в данный момент редактируются
Активный контейнер Выбор цвета фона для активных контейнеров в виде дерева. Например, если в древовидном представлении есть несколько частей и одна часть переключается как активное тело, она получит выбранный цвет фона в древовидном представлении.
Preference Display Tab 02 ru.png

Цвета деталей

Эта вкладка отображается только в том случае, если вы находитесь на верстаке Part или PartDesign или если вы уже были в верстаках.

На вкладке «Цвета детали» вы можете указать следующее:

Параметр Описание
Цвет формы по умолчанию Выбор цвета по умолчанию для новых фигур. Если установлен параметр Случайный цвет формы, вместо него используется случайный цвет.
Цвет линии по умолчанию Выбор цвета линии по умолчанию для новых фигур
Ширина линии по умолчанию Спецификация толщины линии по умолчанию для новых фигур
Цвет вершины по умолчанию Выбор цвета по умолчанию для новой вершины
Размер вершины по умолчанию Указание размера по умолчанию для новой вершины
Цвет охватывающей рамки Выбор цвета охватывающей рамки в 3D виде
Цвет текста по умолчанию Выбор цвета текста по умолчанию для аннотаций документов. В настоящее время нет диалогового окна для добавления аннотаций к документам. Аннотации могут быть добавлены только с помощью консоли Python с помощью этой команды:
obj = App.ActiveDocument.addObject("App::Annotation", "Label")
Эта консоль отображается через меню Вид → Панели → Консоль Python.

obj=App.ActiveDocument.addObject("App::Annotation", "Label")

This console is shown using the menu View → Panels → Python console. |}

Preference Display Tab 03 ru.png

Mesh view

This tab is only shown if you are in the Mesh Workbench or if you have been in this workbench before.

In the Mesh view tab you can specify the following:

Name Description
Default mesh color Selection of the default color for new meshes
Default line color Selection of the default line color for new meshes
Mesh transparency Specification of the default mesh transparency for new meshes
Line transparency Specification of the default line transparency for new meshes
Two-side rendering If checked, the bottom side of the surface will be rendered the same way than the top side. If not checked, it depends on the option Enable backlight color (see section 3D view). Either the backlight color will be used or black.
Show bounding-box for highlighted or selected meshes If checked, a yellow bounding box will be displayed for highlighted or selected meshes.
Define normal per vertex If checked, Phong shading is used, otherwise flat shading. Shading defines the appearance of surfaces.

With flat shading the surface normals are not defined per vertex that leads to a unreal appearance for curved surfaces while using Phong shading leads to a smoother appearance.

Crease angle The crease angle is a threshold angle between two faces. It can only be set if the option Define normal per vertex is used.
If face angle ≥ crease angle, facet shading is used
If face angle < crease angle, smooth shading is used

Mesh View Preferences.png

Настройки импорта-экспорта

The Import-Export settings affect how files are imported and exported to and from FreeCAD. They are described in the page Import Export Preference.

Настройки верстаков

Настройки для более распространенных верстаков приведены ниже. У некоторых верстаков нет предпочтений. Другие дополнительные верстаки могут быть не перечислены.

External workbenches

Настройка интерфейса

С тех пор как интерфейс FreeCAD стал базироваться на современном инструментарии Qt, он стал организован по последней моде. Виджеты, меню, панели инструментов и другие инструменты могут быть изменены, перемещены, обменены между верстаками, установки горячих клавиш можно изменять под себя, также как и сохранять и воспроизводить макросы. Окно настроек можно запустить из меню Tools -> Customize

Screenshot-customize.jpg

Настройки вкладок

Вкладка Commands позволяет Вам просмотреть все команды в FreeCAD, отсортированные по их категориям.

Во вкладке Keyboard, Вы можете просмотреть все ассоциации горячих клавиш в соответствии с каждой командой FreeCAD, и если Вы хотите изменить или назначить (связать) новую ассоциацию для любой команды. Это полезно если вы часто используете программу или определнынные команды (функции), и также желаете повысить эффективность, производительность, скорость, используя клавиатуру.

Пункты меню Toolbars и Toolbox bars позволяют изменять существуюшие панели инструментов, или создать свои.

Пункт Macros позволяет управлять сохраненными Макросами.

Создайте свою панель инструментов для Вашего макроса по учебнику "Настроить панель инструментов"

Начиная с FreeCAD 0.16 доступен новый инструмент, который позволяет вам управлять Вашими верстаками

CustomizeWorkbenches.png

Пример

Для примера хода работ представим, что мы хотим иметь инструмент "Measure Linear" так же в индивидуальной панели в верстаке draft.

  • выберите "Tools -> Customize" в верхнем меню FreeCAD
  • выделите вкладку "Toolbars"
  • слева в ниспадающем меню выберите "Part"
  • в нижнем окне слева пролистайте до элемента "Measure Linear" и выберите его
  • справа в ниспадающем меню выберите "Draft"
  • кликните "New..." для создания новой панели инструментов и выберите для него имя
  • теперь выберите панель назначения в правом нижнем окне (нужно если у вас больше одной панели инструментов)
  • кликнув на голубой "стрелке вправо" (верхней иконке в средней колонке), Вы добавите выбранный элемент в выбранную панель инструментов

Примечания

Выбрав в ниспадающем меню справа "Global", Вы создадите панель, видимую во всех верстаках

Для добавления в панель установленного макроса Вам надо

  • выбрать "Macros" в ниспадающем меню на левой стороне
  • назначить текст меню, иконку (Pixmap) и так далее, используя меню "Tools -> Customize -> Macros"

Свойства объекта


Introduction

Свойство - это доля информации вроде числа или строки текста, прилагаемая к документу 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

Properties play a very important role in FreeCAD. As objects in FreeCAD are "parametric", this means that their behavior is defined by their properties, and how these properties are used as input for their class methods.

All property types

Custom scripted objects can use any of the property types defined in the base system:

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

Internally, the property name is prefixed with App::Property:

App::PropertyBool
App::PropertyFloat
App::PropertyFloatList
...

Remember that these are property types. A single object may have many properties of the same type, but with different names.

For example:

obj.addProperty("App::PropertyFloat", "Length")
obj.addProperty("App::PropertyFloat", "Width")
obj.addProperty("App::PropertyFloat", "Height")

This indicates an object with three properties of type "Float", named "Length", "Width", and "Height", respectively.

Scripting

See also: FreeCAD scripting basics

A scripted object is created first, and then properties are assigned.

obj = App.ActiveDocument.addObject("Part::Feature", "CustomObject")

obj.addProperty("App::PropertyFloat", "Velocity", "Parameter", "Body speed")
obj.addProperty("App::PropertyBool", "VelocityEnabled", "Parameter", "Enable body speed")

In general, Data properties are assigned by using the object's addProperty() method. On the other hand, View properties are normally provided automatically by the parent object from which the scripted object is derived.

For example:

  • Deriving from App::FeaturePython provides only 4 View properties: "Display Mode", "On Top When Selected", "Show In Tree", and "Visibility".
  • Deriving from Part::Feature provides 17 View properties: the previous four, plus "Angular Deflection", "Bounding Box", "Deviation", "Draw Style", "Lighting", "Line Color", "Line Width", "Point Color", "Point Size", "Selectable", "Selection Style", "Shape Color", and "Transparency".

Nevertheless, View properties can also be assigned using the view provider object's addProperty() method.

obj.ViewObject.addProperty("App::PropertyBool", "SupeVisibility", "Base", "Make the object glow")


Работа с инструментариями

FreeCAD, подобно многим современным приложениям для проектирования, таким как Revit или CATIA, базируется на концепции верстаков. Верстаки можно рассматривать как набор инструментов, специально сгруппированных под определенные задачи. В традиционных мебельных мастерских, вы имели бы рабочий стол для человека работающего с деревом, другой для работающего с металлическими частями, и, возможно, третий для того, который монтирует все это вместе.

Тоже самое относится и к FreeCAD. Инструменты сгруппированы в верстаки в соответствии с задачами, к которым они относятся.

Когда вы переключаетесь с одного верстака на другой, доступные в интерфейсе инструменты меняются. Панели инструментов, командные панели и, возможно, другие части интерфейса, переключаются на новый инструментарий, но содержание вашей сцены не меняется. Вы могли бы, например, начать рисовать 2D форму в Чертежном инструментарии, а дальше работать над ней в инструментарии Деталей.

Следует отметить, что иногда верстак называют как модуль. Тем не менее, верстаки и модули разные. Модуль это любое расширение FreeCAD, в то время как верстак специальная конфигурация, это группы нескольких панелей инструментов и меню графического интерфейса. Обычно каждый модуль содержит свой собственный верстак, отсюда и пересечение имён.

Встроенные верстаки

Следующие верстаки доступны в каждой установке FreeCAD:

  • Workbench Arch.svg Модуль Arch для работы с архитектурными элементами.
  • Workbench Complete.svg Верстак Complete содержит все команды и возможности всех модулей и верстаков, соответствующих некоторым критериям качества.удалён в v0.17
  • Workbench Draft.svg Верстак Draft содержит инструменты для двумерного черчения и преобразования их в объёмные тела.
  • Workbench Drawing.svg Верстак Drawing для отображения ваших объёмных работ на плоский лист.
  • Workbench FEM.svg Модуль FEM обеспечивает процесс анализа Методом Конечных Элементов (МКЭ).
  • Workbench Image.svg Модуль Image для работы с растровыми изображениями.
  • Workbench Inspection.svg Модуль Inspection создан, чтобы дать специальные инструменты проверки объёмных тел. Он ещё в стадии проектирования
  • Workbench Mesh.svg Верстак Mesh для работы с триангулированными сетками (полигиональными моделями).
  • Workbench OpenSCAD.svg Модуль OpenSCAD для взаимодействия с OpenSCAD и восстановления истории моделей CSG.
  • Workbench Part.svg Модуль Part используется для работы с деталями САПР.
  • Workbench PartDesign.svg Верстак Part Design Для создания деталей из эскизов
  • Workbench Path.svg Верстак Path используется для генерации G-кодов управления станками и 3D-принтерами. Находится на ранней стадии разработки.
  • Workbench Plot.svg Верстак Plot даёт возможность редактировать и сохранять выходные графики, производимые другими модулями и инструментами.
  • Workbench Points.svg Модуль Points создан для работы с облаками точек.
  • Workbench Raytracing.svg Модуль Raytracing используется для для рендеринга с помощью программ трассировки лучей.
  • Workbench Reverse Engineering.svg Модуль Reverse Engineering должен дать Вам специальные инструменты для превращения многогранников/тел/сетей в параметрические объекты FreeCAD. Пока в стадии разработки.
  • Workbench Robot.svg Модуль Robot предназначен для изучения движений роботов.
  • Workbench Ship.svg Верстак Ship предназначен для работы с водоплавающими судами, которые создаются по заданной геометрии.
  • Workbench Sketcher.svg Модуль Sketcher для работы с эскизами с геометрическими ограничениями.
  • Workbench Spreadsheet.svg Верстак Spreadsheet предназначен для создания и манипуляции данными в электронных таблицах.
  • Workbench Start.svg Центр запуска позволяет быстро перейти в один из наиболее распространённых верстаков.
  • Workbench Surface.svg The Surface workbench Предоставляет инструменты для создания и редактирования поверхностей. Подобен Построителю граней из рёбер.
  • Workbench TechDraw.svg Верстак TechDraw представляет собой более продвинутый и богатый возможностями наследник верстака Drawing
  • Workbench Test.svg The Test framework is for debugging FreeCAD.
  • Workbench Web.svg Модуль Web предоставляет окно браузера на месте трёхмерного вида внутри FreeCAD.

Внешние верстаки

Верстаки FreeCAD легко программируются в Python, поэтому многие разрабатывают дополнительные верстаки вне кодовой базы FreeCAD.

Страница внешние верстаки содержит некоторую информацию и учебники насчёт некоторых из них, а проект FreeCAD Addons нацелен на их привлечение и облегчение их установки внутри FreeCAD.

Новые верстаки находятся в стадии разработки, следите за обновлениями!

Инструментарий Сетка (Mesh)

Workbench Mesh.svg

Верстак Mesh оперирует треугольными сетками. Сетки (Meshes) - это особый тип 3D объектов, составленный из треугольников, соединенных по ребрам и углам (вершинам).

Многие 3D приложений используют сетки (meshes) в качестве основного типа 3D объекта, как sketchup, blender, maya или 3d studio max. Сетки это очень простые объекты, содержащие только вершины (точки), ребра и (треугольные) грани, их очень легко создать, модифицировать, разбивать, растягивать, и можно легко передаваться из одного приложения в другое без потерь. Кроме того, поскольку они определяются очень простыми данными, 3D приложения обычно могут управляться с очень большими их количеством без каких либо проблем. По этим причинам сетки как 3D объекты часто выбирают для приложений, работающих с кино, анимацией и созданием изображений.

Для инженерных применений, однако, сетки обладают очень большим ограничением: это очень примитивный объект, состоящий лишь из точек, линий и граней. Они только создают поверхность, и не содержат информацию о массе, так что они не ведут себя как твердые тела. Для сетки нельзя сразу знать, находится ли точка внутри или за пределами объекта. Это означает что все твердотельные операции, такие как сложение, вычитание, на сетках выполнять всегда труднее, и они часто возвращают ошибки.

Contents

Mesh example.jpg

Использование модуля Mesh

Модуль полигонального моделирования сейчас обладает очень простым интерфейсом, все его функции сгруппированы в меню Сетки. Наиболее важные операции, которые вы можете провести над сеткой:

General tools

  • Mesh Regular Solid.png Правильное геометрическое тело... Создать сеточные примитивы, такие как кубы, сферы, конусы или цилиндры:
    • Mesh Cube.png Создать полигональный куб
    • Mesh Cylinder.png Создаь полигональный цилиндр
    • Mesh Cone.png Создать полигональный конус
    • Mesh Sphere.png Создать полигональную сферу
    • Mesh Ellipsoid.png Создать полигональный эллипсоид
    • Mesh Torus.png Создать полигональный тор
  • Делать булевы операции над сетками

Cutting

Preferences

Это только некоторые из основных операций, доступных в настоящее время доступные в модуле полигонального моделирования.
Гораздо больше полигональных инструментов доступно в верстаке OpenSCAD.
Но в FreeCAD сетки могут быть обработана множеством других способов через написание сценариев.

Meshes can also be handled by Mesh Scripting.

Ссылки

Инструмент Деталь (Part)

Workbench Part.svg

CAD возможности FreeCAD бизируются на ядре OpenCasCade . Модуль частей в FreeCAD открывает доступ к объектам и функциям OpenCasCade. OpenCascade это CAD ядро професионального уровня, это выражается в возможностях продвинутого манипулирование 3D геометрическим манипулированием и объектами. Объекты-детали, в отличии от Полигиональных объектов, являются более сложными, и следовательно дают доступ к более мощным операциям, таким как последовательные логические операции, изменение и истории и параметров построения.

The objects created with the Part Workbench are relatively simple; they are intended to be used with boolean operations (unions and cuts) in order to build more complex shapes. This modelling paradigm is known as the constructive solid geometry (CSG) workflow, and it was the traditional methodology used in early CAD systems. On the other hand, the PartDesign Workbench provides a more modern workflow to constructing shapes: it uses a parametrically defined sketch, that is extruded to form a basic solid body, which is then modified by parametric transformations (feature editing), until the final object is obtained.

Part objects are more complex than mesh objects created with the Mesh Workbench, as they permit more advanced operations like coherent boolean operations, modifications history, and parametric behaviour.

Part example.jpg

Part Workbench relationships.svg

The Part Workbench is the basic layer that exposes the OCCT drawing functions to all workbenches in FreeCAD


Инструменты

Инструменты модуля деталей расположены в меню Деталь, которое появляется при загрузке модуля Part.

Примитивы

Эти инструменты создают примитивные объекты.

  • Part Box.png Куб: Рисует прямоугольный параллелепипед с указанными размерами
  • Part Cylinder.png Цилиндр: Рисует цилиндр с указанными размерами
  • Part Sphere.png Сфера: Рисует сферу с указанными размерами
  • Part Cone.png Конус: Рисует конус с указанными размерами
  • Part Torus.png Тор: Рисует тор (кольцо) с указанными размерами
  • Part CreatePrimitives.png Создать примитивы: Инструмент создания различных параметрических геометрических примитивов
  • Part Shapebuilder.png Построитель форм: Инструмент создания более сложных форм из различных параметрических геометрических примитивов

Изменение объектов

Это инструменты для изменения существующих объектов. Они позволяют вам выбирать, какой объект вы будете изменять.

  • Part Extrude.png Выдавить: Вытягивает плоские грани объекта
  • Part Revolve.png Вращать: Создает объект вращением одного объекта вокруг оси
  • Part Mirror.png Зеркальное отражение: Отражает выбранные объекты на данной зеркальной плоскости
  • Part Fillet.png Скругление: Скругляет ребра объекта
  • Part Chamfer.png Фаска: Делает фаску на гранях объектов
  • Part RuledSurface.png Создать линейчатую поверхность: Этот инструмент создает линейчатую поверхность между двумя линиями или краями выбранных выше.
  • Part Loft.png Лофт: Выполняет лофтинг от одного профиля к другому
  • Part Sweep.png Сдвиг: Развёртывает один или более профилей вдоль заданной трассы
  • Part CompOffsetTools.png Offset tools:
    • Part Offset.png Смещение: Создаёт увеличенную копию оригинального объекта
    • Part Offset2D.png 2D Offset: Создает параллельный провод на определенном расстоянии от оригинала или увеличивает/сжимает плоскую грань. (v0.17)
  • Part Thickness.png Толщина: Назначает толщину поверхностям формы.
  • Part CompJoinFeatures.png Join features: Сложные сопряжения для объектов со стенками (Например, труб) (v0.16)
    • Part JoinConnect.png Connect: Соединяет внутренности объектов (v0.16)
    • Part JoinEmbed.png Embed: Внедряет объект со стенками внутрь другого такого же объекта (v0.16)
    • Part JoinCutout.png Cutout: Создаёт вырез в стенке объекта для другого объекта со стенками (v0.16)
  • Part CompSplittingTools.png Splitting tools: (v0.17)
    • Part BooleanFragments.png Boolean fragments:делает все части, которые могут быть получены с помощью логических операций между объектами (v0.17)
    • Part SliceApart.svg Slice a part: инструмент для разделения фигур путем пересечения с другими формами
    • Part Slice.png Slice: Разбивает объект на части путем пересечения с другим объектом (v0.17)
    • Part XOR.png XOR: удаляет пространство, разделенное четным числом объектов (симметричная версия Cut) (v0.17)

Measure

Std Measure Menu.png Measure: Allows linear and angular measurement between points, edges, and faces.

Прочие инструменты

  • Part ImportCAD.png Импорт CAD: Этот инструмент позволяет добавить в текущий документ файл *.IGES, *.STEP, *.BREP.
  • Part ExportCAD.png Экспорт в CAD: Этот инструмент позволяет экспортировать деталь в формате *.IGES, *.STEP, *.BREP.
  • Part ShapeFromMesh.png Создание формы из сетки: Creates a shape object from a mesh object.
  • Convert to solid: Преобразует форму в твердое тело.
  • Обратная фигура: Отражает нормали всех граней выбранного объекта.
  • Создать простую копию: Создаёт копию выбранного объекта без истории и возможности параметрического редактирования.
  • Part RefineShape.png Уточнить форму: Очищает поверхности удалением ненужных линий.
  • Part CheckGeometry.png Проверка геометрии: Проверяет геометрию выбранных объектов на ошибки.
  • Measure: Даёт доступ к линейным и угловым измерениям между точками/гранями/поверхностями.
  • Part Attachment.svg прикрепление: прикрепление- это утилита для прикрепления объекта к другому.

Preferences

Объяснение концепции

В терминологии OpenCasCade геометрические примитивы и (топологические) формы различны. Геометрическим примитивом может быть точка, линия, окружность, плоскость и т.д. , или даже более сложные типы, такие как кривая B-сплайна или поверхность. Формой может быть вешина, ребро, сеть , грань, твердое тело или соединение всего этого. Геометрические примитивы не созданы специально для того чтобы отображаться на 3D сцене, они используются в качестве строительной геометрии форм. Для примера, ребро можно построить из линии или же из части окружности.

В итоге можно сказать, что геометрические примитивы есть "бесформенные" строительные блоки, а формы это реальная пространственная геометрия, построенная по ним.

Чтобы получить полный список объектов что к ним относится обратитесь к документации OCC в разделах Geom_Geometry и TopoDS_Shape. Также вы больше сможете узнать о различиях геометрических объектов и форм. Обратите внимание что к сожалению документация OCC не доступна в Интернете(вы должны скачать архив) и в основном направлена на программистов, а не на конечных пользователей. Но надеемся, что вы найдете здесь достаточно информации для начала.

Геометрические типы на самом деле можно разделить на две основные группы: кривые и поверхности. Из кривых (линия, окружность, ...) вы непосредственно можете строить ребра, из поверхностей (плоскость, цилиндр, ...) могут быть построены грани. Например, такой геометрический примитив как линия - бесконечен, т.е. он задается только вектором направления в то время, как его форма должна быть представлено чем-то ограниченым обладающим начальной и конечной точкой. Также и box -- твердое тело -- которое может быть создано из шести ограниченых плоскостей.

От ребра или грани, вы также можете вернутся к геометрическим примитивам из которых они состоят.

Таким образом, из форм вы можете построить очень сложные детали или , или наоборот, извлечь все субформы из созданой сложной формы.

Написание сценариев

See also: Part scripting

Основным структурой данных в модуле Деталей является BRep тип данных из OpenCascade. Все содержащиеся в модуле Деталей типы объектов и функции доступны в сценариях на Python. Это включает в себя геометрические примитивы, такие как Линия[Line] и Окружность[Circle] (или Дуга[Arc]), и целый ряд TopoShapes, таких как Вершины[Vertexes], Ребра[Edges], Сетки[Wires], Грани[Faces], Тела[Solids] и Составные объекты[Compounds]. Каждый из этих объектов, можно создать несколькими способами, и для некоторых из них особенно для TopoShapes, существуют продвинутые операции например логическое сложение/вычитание/пересечение которые также доступны. Чтобы знать больше изучите содержание модуля Деталей, описанное на странице Основы написания сценариев в FreeCAD .

The most basic object that can be created is a Part Feature, which has a simple DATAPlacement property, and basic properties to define its color and appearance.

Another simple object used in 2D geometrical objects is Part Part2DObject, which is the base of Sketches, and most Draft elements.

Примеры

Чтобы создать элемент - линию перейдите в консоль Python и введите:

import Part,PartGui 
doc=App.newDocument()  
l=Part.LineSegment()
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()

Давайте по подробней, по шагам рассмотрим пример выше:

import Part,PartGui
doc=App.newDocument()

загружает модуль деталей и создает новый документ

l=Part.LineSegment()
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' добавленного объекта. Важно понять, здесь мы использовали геометрический примитив (the Part.lineSegment) чтобы создать TopoShape в конце (используя toShape() метод). Только Формы могут быть добавлены в документ. В FreeCAD, геометрические примитивы используются как "строительные конструкций" для Форм.

doc.recompute()

Обновили документ. Это также должно полготовить визуальное представление нового объекта-Детали.

Заметим что Линия[Line] Segment может быть создана специфическим способом, заданием её начальной и конечной точки напрямую, пример Part.LineSegment(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, долее забираем выводим список ребер, в нашем случае будет только одна, потому что мы создали форму из одного оеружности, поэтому мы получим только одну запись в списке ребер, и мы выводим кривую. Каждое ребро это кривая, которая является геометрическим примитивом на котором оно основано.

Читайте главу Topological data scripting/ru если хотите знать больше.

Учебники

Инструментарий Черчениея

Workbench Drawing.svg

Introduction

Development of the Drawing Workbench stopped in FreeCAD 0.16, and the new TechDraw Workbench aiming to replace it was introduced in v0.17. Both workbenches are still provided in v0.17, but the Drawing Workbench may be removed in future releases.


Модуль Черчения позволяет поместить ваши 3D наработки на бумагу. То есть, поместить проекции ваших моделей в 2D окно и вставить это окно в рисунок, например на лист с рамкой, вашим заголовком и логотипом и наконец распечатать всё это. Модуль черчения находится в стадии разработки и приблизительного технологического тестирования!

Drawing extraction.png

GUI Инструменты

Это инструменты для создания, настройки и экспортирования 2D чертежных листов

  • Drawing New.png Открыть SVG: Открывает чертеж, ранее сохранённый в формате SVG
  • Drawing Annotation.png Аннотация: Добавляет аннотацию на текущий чертёжный лист
  • Drawing Clip.png Клип: Добавляет группу клипов на текущий чертёжный лист
  • Drawing Openbrowser.png Открыть в браузере: Открывает предварительный просмотр текущего чертёжного листа в браузере
  • Drawing Symbol.png Символ: Добавляет содержимое файла SVG как символ на текущий чертёжный лист
  • Drawing DraftView.png Draft View: Вставляет специальный вид выбранного объекта на текущий чертёжный лист
  • Drawing SpreadsheetView.png Spreadsheet View: Вставляет вид выбранного листа электронной таблицы на текущий чертёжный лист
  • Проекция фигуры: Создаёт проекцию выбранного объекта (источинка) в трёхмерном виде.

Примечание Инструмент Draft View главным образом используется, чтобы поместить чертёжные объекты на бумагу. Он имеет множество дополнительных возможностей кроме стандартных чертёжных инструментов, и поддерживает специффические объекты вроде размеров на чертеже.

На картинке вы видите, основные концепции модуля Черчения. Документ содержит объект-форму (Schenkel) который мы хотим извлечь для черчения. Поэтому создается "Лист". Лист автоматически получает шаблон, в данном случае шаблон "A3_Landscape". Этот шаблон представляет собой документ SVG и может содержать обычную чертежную рамку, ваш логотип или же соответствовать вашим собственным стандартам.

На этот лист вы можете поместить один и более видов. Каждый вид обладает своей позицией на странице (свойства X,Y), и коэффициентом масштабирования (свойство scale) и другие дополнительные свойства. Каждый раз когда лист или вид или объект на который они ссылаются, изменяются лист перерисовывается, и отображение листа обновляется.

Написание сценариев

На данный момент рабочий процес для конечного пользователя(GUI) очень ограничен, поэтому интересней писать сценарии для API. Ниже следуют примеры о том как сценариев API чертежного модуля.

See the Drawing API example page for a description of the functions used to create drawing pages and views.

Это скрипт, с помощью которого можно легко заполнить лист Macro_CartoucheFC FreeCAD A3_Landscape.

Шаблоны

FreeCAD поставляется вместе с набором стандартных шаблонов, но вы также можете найти больше на странице Чертежных шаблонов .

Расширение модуля Drawing

Некоторые примечания по программной стороне модуля были добавлены на страницу Drawing Documentation. Это для быстрого понимания, как работает модуль Drawing, позволяя программистам быстро начать программирование для него.

Учебники

Внешние ссылки

Инструментарий Трассировка лучей

Workbench Raytracing.svg

Этот модуль предназначен для создания фотореалистичной изображения ваших моделей с помощью внешних программ рендеринга. Модуль работает с помощью шаблонов, точно так же как верстак Drawing, позволяя создать проект трассировки лучей, куда Вы можете добавить виды ваших объектов. Проект может быть экспортирован в готовый для рендеринга файл, или отрисован напрямую.

The Raytracing Workbench works with templates, which are project files that define a scene for your 3D model. You can place lights and geometry such as ground planes, and it also contains placeholders for the position of the camera, and for the material information of the objects in the scene. The project can then be exported to a ready-to-render file, or be rendered directly within FreeCAD.

Currently, two renderers are supported: povray and luxrender. To be able to render from within FreeCAD, at least one of these programs must be installed and configured in your system. However, if no renderer is installed, you will still be able to export a project file to be rendered at another time.

A new Render Workbench has been in development to support multiple back-ends such as Lux Renderer and Yafaray. Information for using the development version can be viewed at Render project. For development status of the Render Module look into the Raytracing project.

Raytracing example.jpg

Typical workflow

  1. Create or open a FreeCAD project, add some solid objects (Part-based or PartDesign-based); meshes are currently not supported.
  2. Create a Raytracing project (povray or luxrender).
  3. Select the objects that you wish to add to the Raytracing project and add them.
  4. Export the project file or render it directly.


Raytracing Workbench workflow.svg


Workflow of the Raytracing Workbench; the workbench prepares a project file from a given template, and then calls an external program to produce the actual rendering of the scene. The external renderer can be used independently of FreeCAD.


GUI Инструменты

Project tools

These are the main tools for exporting your 3D work to external renderers.

  • Raytracing New.png New PovRay project: Insert new PovRay project in the document
  • Raytracing Lux.png New LuxRender project: Insert new LuxRender project in the document
  • Raytracing InsertPart.png Insert part: Insert a view of a Part in a raytracing project
  • Raytracing ResetCamera.png Reset camera: Matches the camera position of a raytracing project to the current view
  • Raytracing ExportProject.png Export project: Exports a raytracing project to a scene file for rendering in an external renderer
  • Raytracing Render.png Render: Renders a raytracing project with an external renderer

Utilities

These are helper tools to perform specific tasks manually.

Preferences

  • Preferences-raytracing.svg Preferences: Preferences available in for the Raytracing tools.

Tutorials

Creating a povray file manually

The utility tools described above allow you to export the current 3D view and all of its content to a Povray file. First, you must load or create your CAD data and position the 3D View orientation as you wish. Then choose "Utilities → Export View..." from the raytracing menu.

FreeCAD Raytracing.jpg

You will be asked for a location to save the resulting *.pov file. After that you can open it in Povray and render:

Povray.jpg

As usual in a renderer you can make big and nice pictures:

Scharniergreifer render.jpg

Написание сценариев

See the Raytracing API example for information on writing scenes programmatically.

Ссылки

POVRay

Luxrender

Future possible renderers to implement

Exporting to Kerkythea

Although direct export to the Kerkythea XML-File-Format is not supported yet, you can export your Objects as Mesh-Files (.obj) and then import them in Kerkythea.

  • if using Kerkythea for Linux, remember to install the WINE-Package (needed by Kerkythea for Linux to run)
  • you can convert your models with the help of the mesh workbench to meshes and then export these meshes as .obj-files
  • If your mesh-export resulted in errors (flip of normals, holes ...) you may try your luck with netfabb studio basic
Free for personal use, available for Windows, Linux and Mac OSX.
It has standard repair tools which will repair you model in most cases.
  • another good program for mesh analysing/repairing is Meshlab
Open Source, available for Windows, Linux and Mac OSX.
It has standard repair tools which will repair you model in most cases (fill holes, re-orient normals, etc.)
  • you can use "make compound" and then "make single copy" or you can fuse solids to group them before converting to meshes
  • remember to set in Kerkythea an import-factor of 0.001 for obj-modeler, since Kerkythea expects the obj-file to be in m (but standard units-scheme in FreeCAD is mm)
Within WIndows 7 64-bit Kerkythea does not seem to be able to save these settings.
So remember to do that each time you start Kerkythea
  • if importing multiple objects in Kerkythea you can use the "File → Merge" command in Kerkythea

Development

Инструментарий Изображение

Workbench Image.svg

Введение

Верстак Image обрабатывает различные типы растровых изображений, и позволяет открыть их в FreeCAD.

Сейчас модуль поддерживает форматы файлов BMP, JPG, PNG, и XPM.

Инструменты

  • Image-import.svg Open: открыть изображение в новой точке зрения.
  • Image-import-to-plane.svg Import to plane: импортировать изображение на плоскость в окне трёхмерного вида.
  • Image-scale.svg Scaling: масштабировать изображение, импортированное на плоскость.

Особенности

  • Подобно Sketch, импортированное изображение может быть присоединено к одной из главных плоскостей XY, XZ или YZ, и иметь положительное или отрицательное смещение.
  • Изображение импортируется в соотношении 1 мм на пиксель.
  • Рекомендуется импортировать изображение в разумном разрешении.

Работа

Основное применение этого верстака в трассировке поверх изображения с помощью инструментов Draft или Sketcher, для генерации твёрдого тела на основе контуров изображения.

Трассировка эскизированием поверх изображения работает лучше при небольшом отрицательном смещении изображения относительно эскиза, например, -0,1 мм относительно рабочей плоскости. То есть изображение будет немного под плоскостью где Вы рисуете свою двумерную геометрию, так что Вы не рисуете на самом изображении.

Смещение может быть установлено при импорте, или позднее, редактированием положения изображения.



Инструмент 2D черчение

Workbench Draft.svg

Верстак Draft позволяет быстро начертить в текущем документе простые двумерные объекты и предлагает некоторые инструменты для их модификации. Некоторые из этих инструментов так же работают на других объектах FreeCAD, сделанных не на верстаке Draft. На верстаке имеется полнофункциональная система привязки и некоторые утилиты для управления объектами и установками.

The created 2D objects can be used for general drafting in a way similar to Inkscape or Autocad. These 2D shapes can also be used as the base components of 3D objects created with other workbenches, for example, the Part and Arch Workbenches. Conversion of Draft objects to Sketches is also possible, which means that the shapes can also be used with the PartDesign Workbench for the creation of solid bodies.

FreeCAD is primarily a 3D modelling application, and thus its 2D tools aren't as advanced as in other drawing programs. If your primary goal is the production of complex 2D drawings and DXF files, and you don't need 3D modelling, you may wish to consider a dedicated software program for technical drafting such as LibreCAD, QCad, TurboCad, and others.

Draft Workbench Example

Черчение объектов

Инструменты для создания объектов.

  • Draft Line.png Линия: создать отрезок через две точки
  • Draft Wire.png DWire (полилиния): создать кривую, состоящую из отрезков (полилинию)
  • Draft Circle.png Окружность: pисует правильный многоугольник от центра, радиуса и количества сторон
  • Draft Arc.png Дуга: создать дугу по центру, радиусу и начальному и конечному углу
  • Draft Ellipse.png Эллипс: создать эллипс по двум угловым точкам
  • Draft Polygon.png Многоугольник: создать правильный многоугольник по из центру и радиусу
  • Draft Rectangle.png Прямоугольник: создать прямоугольник по двум противоположным точкам
  • Draft Text.png Текст: создать многострочную текстовую аннотацию
  • Draft Dimension.png Размер: создать размерную линию
  • Draft BSpline.png B-сплайн: создать B-сплайн из последовательности точек
  • Draft Point.png Точка: создать точку
  • Draft ShapeString.png Текст в кривую: создать сложную форму, представляющую текстовую строку
  • Draft Facebinder.png Граневяз: создать новый объект из выбранных граней существующих объектов
  • Draft BezCurve.png Кривая Безье: создать кривую Безье из последовательности точек
  • Draft Label.png этикетка: Подписанные места со стрелкой, указывающей на выбранный элемент available in version 0.17

Изменение объектов

Эти инструменты изменяют существующие объекты. Они работают на выбранных объектах, но если ни одного объекта не выбрано, вам будет предложено его выбрать.

Many operation tools (move, rotate, array, etc.) also work on solid objects (Part, PartDesign, Arch, etc.).

Утилиты инструменты

Через контекстное меню по правому клику мыши доступны дополнительные инструменты, зависящие от выбранного объекта.

Предпочтения

Форматы файлов

Верстак Draft позволяет FreeCAD импортировать и экспортировать следующие форматы файлов:

Дополнительные возможности

  • Привязка: позволяет разместить новые точки на специальных частях существующих объектов
  • Геометрические ограничения: позволяет разместить новые точки горизонтально или вертикально относительно предыдущих точек
  • Работа с координатами вручную: позволяет вводить координаты вручную, вместо указания их на экране
  • Рабочая плоскость: позволяет задать плоскость в трёхмерном пространстве, где будут проводиться операции с плоскими фигурами

Сценарии

Модуль Draft предоставляет полный набор API, что делает возможным использование его функций в сценариях и макросах.

Сценарии и макросы

Макросы

Introduction

Макросы удобный способ создания сложных действий в FreeCAD. Вы просто записываете свои действия, в то время как вы их делаете, а затем сохраняете, это под названием, и воспроизводите их, когда вы хотите. Поскольку макросы в действительности список команд Python, вы можете также редактировать их, и создавать очень сложные сценарии.

While Python scripts normally have the .py extension, FreeCAD macros should have the .FCMacro extension. A collection of macros written by experienced users is found in the macros recipes page.

See Introduction to Python to learn about the Python programming language, and then Python scripting tutorial and FreeCAD Scripting Basics to learn about writing macros.

Как это работает

Если включить вывод в консоль (меню Edit -> Preferences -> General -> Macros -> Show scripts commands in python console), вы увидите, что в FreeCAD, каждое действие что вы совершаете, например, при нажатии кнопки, выводится как Python команда. Эти команды могут быть записаны в макрос. Основным инструментом для создания макросов является панель инструментов макросы: Macros toolbar.jpg. На это у вас есть 4 кнопки: запись(record), остановка записи(stop), редактирования и воспроизведения текущего макроса(edit and play the current macro).

Его очень просто использовать: нажмите кнопку записи, вам будет предложено дать имя вашему макросу, а затем выполнить некоторые действия. Когда вы закончите, нажмите кнопку остановки записи, и ваши действия будут сохранены. Теперь вы можете получить доступ к диалогу макроса с помощью кнопки редактирования:

Macros.png

There you can manage your macros, delete, edit, duplicate, install or create new ones from scratch. If you edit a macro, it will be opened in an editor window where you can make changes to its code. New macros can be installed using the Addons... button, which links to the Addon Manager.

Пример

Нажмите кнопку записи(record), дайте имя, скажем, "cylinder 10x10", а затем, в инструментарии деталей, создайте цилиндр с радиусом = 10 и высотой = 10. Затем нажмите "Остановить запись(stop)" кнопку. В диалоге редактирования макросов, вы можете увидеть Python код, который был записан, и, если вы хотите, произведите изменения в нем. Чтобы выполнить макрос, просто нажмите кнопку execute на панели инструментов, пока ваш макрос в редакторе. Ваш макрос всегда сохраняется на диске, поэтому любые изменения которые вы делаете, или каких-либо новые созданные макросы, всегда будут доступны при следующем запуске FreeCAD.

Настройка

Конечно, это не практично загружать макрос в редактор, затем чтобы использовать его. FreeCAD предоставляет гораздо лучшие способы использования макросов, такие как на них назначение клавиш, или добавлении записи в меню. Как только ваш макрос будет создан, все это можно сделать через Tools -> Customize menu:

Macros config.jpg

Customize Toolbars

Таким образом, вы можете сделать ваш макрос реальным инструментом, как и любой стандартный инструмент FreeCAD. Это, приумножает власть Python сценариев в FreeCAD, позволяет с легкостью добавлять ваши собственные инструменты для интерфейса. Читайте дальше, Написание сценариев , если вы хотите знать больше о Python сценариях ...

Создание макросов без записи

How to install macros Вы также можете непосредственно копировать/вставлять Python код в макрос, без записи GUI действий. Просто создайте новый макрос, редактируйте его и вставте код. Затем можно сохранить макрос так же, как вы сохраняете документ FreeCAD. При следующем запуске FreeCAD, макрос появится в пункте меню "Installed Macros".

Хранилище макросов

Посетите страницу Сборник макросов где вы можете выбрать некоторые полезные макросы, чтобы добавить их к своей системе, FreeCAD.


Введение в Python

(January 2020) FreeCAD was originally designed to work with Python 2. Since Python 2 reached end of life in 2020, future development of FreeCAD will be done exclusively with Python 3, and backwards compatibility will not be supported. The information here describes Python 2, but most of the code should work the same with Python 3. In particular, the print() function is preferred over the old print statement.


Это небольшой учебник, созданный для тех, кто хочет начать программирование на Python. Python - это язык с открытым исходным кодом и кросс-платформенным языком программирования.язык програмирования. Python имеет множество функций, которые отличает его от других языков программирования и легко доступны для всех, кто хочет попасть в программирование:

  • Он был разработан специально для легкого чтения людьми, и поэтому его очень легко узнать и понять.
  • Он интерпретируется, то есть, в отличие от скомпилированных языков, таких как C, ваша программа не нуждается в компиляции до ее выполнения. Код, который вы пишете, может быть немедленно выполнен, если хотите. Поскольку вы можете идти медленно, шаг за шагом, очень легко учиться и находить ошибки в вашем коде.
  • Он может быть встроен в другие программы, которые будут использоваться в качестве языка сценариев. FreeCAD имеет встроенный интерпретатор Python; вы можете написать код Python в FreeCAD, который будет манипулировать частями FreeCAD, например, для создания геометрии. Это чрезвычайно мощно, вместо того, чтобы просто нажимать кнопку с надписью «create sphere», которую закодировал какой-то программист; у вас есть свобода легко создавать собственный инструмент, создавая именно ту геометрию, которую вы хотите, в манере или форме, которые программист не может предвидеть.
  • Он расширяемый, вы можете легко подключить новые модули к вашей установке Python и расширить его функциональность. Например, у вас есть модули, которые позволяют Python читать и писать jpg-изображения, общаться с твиттером, планировать задачи, которые будут выполняться вашей операционной системой, и т. Д.

Мы настоятельно рекомендуем вам вводить фрагменты кода ниже в интерпретатор Python. Для многих наших примеров важным моментом является строка после выполнения кода, результат. А теперь на работе! Имейте в виду, что следующее является упрощенным введением и ни в коем случае не полным учебником. Но мы надеемся, что после этого чтения вы приобретете необходимые основы для более глубокого изучения и использования механизмов FreeCad.

The interpreter

Usually, when writing computer programs, you simply open a text editor or your special programming environment, (which is usually a text editor with several additional tools) write your program, then compile and execute. Usually, one or more errors were made during entry, so your program won't work. You may even get an error message telling you what went wrong. Then you go back to your text editor, correct the mistakes, run again, repeating until your program works as intended.

That whole process, in Python, can be done transparently inside the Python interpreter. The interpreter is a Python window with a command prompt, where you can simply type Python code. If you install Python on your computer (download it from the Python website if you are on Windows or Mac, install it from your package repository if you are on GNU/Linux), you will have a Python interpreter in your start menu. But FreeCAD also has a Python interpreter in its lower window:

Screenshot pythoninterpreter.jpg

(If you don't have it, click on View --> Panels --> Python console.)

The interpreter shows the Python version, then a >>> symbol, which is the command prompt, that is, where you enter Python code. Writing code in the interpreter is simple: one line is one instruction. When you press Enter, your line of code will be executed (after being instantly and invisibly compiled). For example, try writing this:

print "hello"

print is a special Python keyword that means, obviously, to print something on the screen. When you press Enter, the operation is executed, and the message "hello" is printed. If you make an error, for example let's write:

print hello

Python will tell us that it doesn't know what hello is. The " characters specify that the content is a string, which is simply, in programming jargon, a piece of text. Without the ", the print command believed hello was not a piece of text but a special Python keyword. The important thing is, you immediately get notified that you made an error. By pressing the up arrow (or, in the FreeCAD interpreter, CTRL+up arrow), you can go back to the last command you wrote and correct it.

The Python interpreter also has a built-in help system. Try typing:

help

or, for example, let's say we don't understand what went wrong with our print hello command above, we want specific information about the "print" command:

help("print")

You'll get a long and complete description of everything the print command can do.

Now that we totally dominate our interpreter, we can begin with the serious stuff.

Variables

Of course, printing "hello" is not very interesting. More interesting is printing stuff you didn't know before, or let Python find for you. That's where the concept of the variable comes in. A variable is simply a value that you store under a name. For example, type this:

a = "hello"
print a

I guess you understood what happened, we "saved" the string "hello" under the name "a." Now, "a" is not an unknown name any more! We can use it anywhere, for example in the print command. We can use any name we want, just follow some simple rules, like not using spaces or punctuation. For example, we could write:

hello = "my own version of hello"
print hello

See? now hello is not an undefined word any more. What if, by terrible bad luck, we choose a name that already exists in Python? Let's say we want to store our string under the name "print":

print = "hello"

Python is very intelligent and will tell us that this is not possible. It has some "reserved" keywords that cannot be modified. But our variables can be modified any time, that's why they are called variables, the contents can vary. For example:

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

We changed the value of myVariable. We can also copy variables:

var1 = "hello"
var2 = var1
print var2

Note that it is important to give meaningful names to your variables. After a while you won't remember what your variable named "a" represents. But if you named it, for example myWelcomeMessage, you'll easily remember its purpose. Plus your code is a step closer to being self-documenting.

Case is very important. myVariable is not the same as myvariable, the difference in the upper/lower case v. If you were to enter print myvariable it would come back with an error as not defined.

Numbers

Of course you must know that programming is useful to treat all kinds of data, and especially numbers, not only text strings. One thing is important, Python must know what kind of data it is dealing with. We saw in our print hello example, that the print command recognized our "hello" string. That is because by using the ", we told specifically the print command what follows next is a text string.

We can always check the data type of a variable with the special Python keyword type:

myVar = "hello"
type(myVar)

It will tell us the contents of myVar is 'str', short for string in Python jargon. We have also other basic types of data, such as integer and float numbers:

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

This is much more interesting, isn't it? Now we have a powerful calculator! Look at how well it worked, Python knows that 10 and 20 are integer numbers. So they are stored as "int", and Python can do with them everything it can do with integers. Look at the results of this:

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

See? We forced Python to consider that our two variables are not numbers but mere pieces of text. Python can add two pieces of text together, but it won't try to find out any sum. But we were talking about integer numbers. There are also float numbers. The difference is that integer numbers don't have decimal part, while float numbers can have a decimal part:

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

Int and Floats can be mixed together without problem:

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

Of course the total has decimals, right? Then Python automatically decided that the result is a float. In several cases such as this one, Python automatically decides what type to use. In other cases it doesn't. For example:

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

This will give us an error, varA is a string and varB is an int, and Python doesn't know what to do. However, we can force Python to convert between types:

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

Now both are strings, the operation works! Note that we "stringified" varB at the time of printing, but we didn't change varB itself. If we wanted to turn varB permanently into a string, we would need to do this:

varB = str(varB)

We can also use int() and float() to convert to int and float if we want:

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

Note on Python commands

You must have noticed that in this section we used the print command in several ways. We printed variables, sums, several things separated by commas, and even the result of other Python command such as type(). Maybe you also saw that doing those two commands,

type(varA)
print type(varA)

have exactly the same result. That is because we are in the interpreter, and everything is automatically printed. When we write more complex programs that run outside the interpreter, they won't print automatically, so we'll need to use the print command. From now on, let's stop using it here, it'll go faster. So we can simply write:

myVar = "hello friends"
myVar

You must have seen that most of the Python commands (or keywords) type(), int(), str(), etc. have parenthesis to limit the command contents. The only exception is the print command, which in fact is not really an exception, as it also works normally: print("hello"). However, since it is used often, the Python designers allowed a simpler version.

Lists

Another interesting data type is a list. A list is simply a collection of other data. The same way that we define a text string by using " ", we define a list by using [ ]:

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

You see that it can contain any type of data. Lists are very useful because you can group variables together. You can then do all kinds of things within that group, for example counting them:

len(myOtherList)

or retrieving one item of a list:

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

You see that while the len() command returns the total number of items in a list, their "position" in the list begins with 0. The first item in a list is always at position 0, so in our myOtherList, "Bob" will be at position 2. We can do much more with lists, you can read here, such as sorting contents, removing or adding elements.

A funny and interesting thing: a text string is very similar to a list of characters! Try doing this:

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

Usually, what you can do with lists can also be done with strings. In fact both lists and strings are sequences.

Outside strings, ints, floats and lists, there are more built-in data types, such as dictionaries, or you can even create your own data types with classes.

Indentation

One big cool use of lists is also browsing through them and do something with each item. For example look at this:

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

We iterated (programming jargon) through our list with the "for ... in ..." command and did something with each of the items. Note the special syntax: the for command terminates with : indicating the following will be a block of one of more commands. In the interpreter, immediately after you enter the command line ending with :, the command prompt will change to ... which means Python knows that a colon (:) ended line has happened and more is coming.

How will Python know how many of the next lines will be to be executed inside the for...in operation? For that, Python uses indentation. That is, your next lines won't begin immediately. You will begin them with a blank space, or several blank spaces, or a tab, or several tabs. Other programming languages use other methods, like putting everything inside parenthesis, etc. As long as you write your next lines with the same indentation, they will be considered part of the for-in block. If you begin one line with 2 spaces and the next one with 4, there will be an error. When you finished, just write another line without indentation, or simply press Enter to come back from the for-in block

Indentation is cool because it aids in program readability. If you use large indentations (for example use tabs instead of spaces because it's larger), when you write a big program you'll have a clear view of what is executed inside what. We'll see that commands other than for-in, can have indented blocks of code too.

For-in commands can be used for many things that must be done more than once. It can, for example, be combined with the range() command:

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

(If you have been running the code examples in an interpreter by Copying and Pasting, you will find the previous block of text will throw an error. Instead, copy to the end of the indented block, i.e. the end of the line total = total + number and then paste to the interpreter. In the interpreter issue an <enter> until the three dot prompt disappears and the code runs. Then copy the final two lines into the interpreter followed by one or more <enter> The final answer should appear.)

If you would type into the interpreter help(range) you would see:

range(...)
    range(stop) -> list of integers
    range(start, stop[, step]) -> list of integers

Here the square brackets denote an optional parameter. However all are expected to be integers. Below we will force the range parameters to be an integer using int()

decimales = 1000                     # for 3 decimales 
#decimales = 10000                   # for 4 decimales ...
for i in range(int(0 * decimales),int(180 * decimales),int(0.5 * decimales)):
    print float(i) / decimales

Or more complex things like this:

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

You see that the range() command also has that strange particularity that it begins with 0 (if you don't specify the starting number) and that its last number will be one less than the ending number you specify. That is, of course, so it works well with other Python commands. For example:

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

Another interesting use of indented blocks is with the if command. If executes a code block only if a certain condition is met, for example:

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

Of course this will always print the first sentence, but try replacing the second line by:

if "Lucky" in alldaltons:

Then nothing is printed. We can also specify an else: statement:

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

Functions

There are few standard Python commands. In the current version of Python, there are about 30, and we already know several of them. But imagine if we could invent our own commands? Well, we can, and it's extremely easy. In fact, most the additional modules that you can plug into your Python installation do just that, they add commands that you can use. A custom command in Python is called a function and is made like this:

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

(Another copy and paste error, only copy through the end of the indented section i.e. " square meters" Paste to the interpreter, and issue <enter> until the three dot prompt goes a way, then copy and paste the final line.)

Extremely simple: the def() command defines a new function. You give it a name, and inside the parenthesis you define arguments that we'll use in our function. Arguments are data that will be passed to the function. For example, look at the len() command. If you just write len() alone, Python will tell you it needs an argument. That is, you want len() of something, right? Then, for example, you'll write len(myList) and you'll get the length of myList. Well, myList is an argument that you pass to the len() function. The len() function is defined in such a way that it knows what to do with what is passed to it. Same as we did here.

The "myValue" name can be anything, and it will be used only inside the function. It is just a name you give to the argument so you can do something with it, but it also serves to tell the function how many arguments to expect. For example, if you do this:

printsqm(45,34)

There will be an error. Our function was programmed to receive just one argument, but it received two, 45 and 34. We could instead do something like this:

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

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

We made a function that receives two arguments, sums them, and returns that value. Returning something is very useful, because we can do something with the result, such as store it in the myTotal variable. Of course, since we are in the interpreter and everything is printed, doing:

sum(45,34)

will print the result on the screen, but outside the interpreter, since there is no print command inside the function, nothing would appear on the screen. You would need to:

print sum(45,34)

to have something printed. Read more about functions here.

Modules

Now that we have a good idea of how Python works, we'll need one last thing: How to work with files and modules.

Until now, we wrote Python instructions line by line in the interpreter, right? What if we could write several lines together, and have them executed all at once? It would certainly be handier for doing more complex things. And we could save our work too. Well, that too, is extremely easy. Simply open a text editor (such as the windows notepad, Linux gedit, emacs, or vi), and write all your Python lines, the same way as you write them in the interpreter, with indentations, etc. Then, save that file somewhere, preferably with a .py extension. That's it, you have a complete Python program. Of course, there are much better editors than notepad, but it is just to show you that a Python program is nothing else than a text file.

To make Python execute that program, there are hundreds of ways. In windows, simply right-click your file, open it with Python, and execute it. But you can also execute it from the Python interpreter itself. For this, the interpreter must know where your .py program is. In FreeCAD, the easiest way is to place your program in a place that FreeCAD's Python interpreter knows by default, such as FreeCAD's bin folder, or any of the Mod folders. (In Linux, you probably have a directory /home/<username>/.FreeCAD/Mod, let's add a subdirectory to that called scripts where we will put the text file.) Suppose we write a file like this:

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

print "myTest.py succesfully loaded"

and we save it as myTest.py in our FreeCAD/bin directory (or on Linux to /home/<username>/.FreeCAD/Mod/scripts.) Now, let's start FreeCAD, and in the interpreter window, write:

import myTest

without the .py extension. This will simply execute the contents of the file, line by line, just as if we had written it in the interpreter. The sum function will be created, and the message will be printed. There is one big difference: the import command is made not only to execute programs written in files, like ours, but also to load the functions inside, so they become available in the interpreter. Files containing functions, like ours, are called modules.

Normally when we write a sum() function in the interpreter, we execute it simply like that:

sum(14,45)

Like we did earlier. When we import a module containing our sum() function, the syntax is a bit different. We do:

myTest.sum(14,45)

That is, the module is imported as a "container", and all its functions are inside. This is extremely useful, because we can import a lot of modules, and keep everything well organized. So, basically, everywhere you see something.somethingElse, with a dot in between, that means somethingElse is inside something.

We can also import our sum() function directly into the main interpreter space, like this:

from myTest import *
sum(12,54)

Basically all modules behave like that. You import a module, then you can use its functions: module.function(argument). Almost all modules do that: they define functions, new data types and classes that you can use in the interpreter or in your own Python modules, because nothing prevents you from importing other modules inside your module!

One last extremely useful thing. How do we know what modules we have, what functions are inside and how to use them (that is, what kind of arguments they need)? We saw already that Python has a help() function. Doing:

help()
modules

Will give us a list of all available modules. We can now type q to get out of the interactive help, and import any of them. We can even browse their content with the dir() command

import math
dir(math)

We'll see all the functions contained in the math module, as well as strange stuff named __doc__, __file__, __name__. The __doc__ is extremely useful, it is a documentation text. Every function of (well-made) modules has a __doc__ that explains how to use it. For example, we see that there is a sin function in side the math module. Want to know how to use it?

print math.sin.__doc__

(It may not be evident, but on either side of doc are two underscore characters.)

And finally one last little goodie: When we work on a new or existing module, it's best to replace the file extension with py such as: myModule.FCMacro => myModule.py. We often want to test it so we will load it as above.

import myModule
myModule.myTestFunction()

But what if we see that myTestFunction() doesn't work correctly? We go back to our editor and make changes. Then, instead of closing and reopening the python interpreter, we can simply update the module like this:

reload(myModule)

This file renaming is because Python doesn't know about the extension FCMacro.

However, there are two alternates: Inside the one macro use Python's exec or execfile functions.

f = open("myModule","r")
d = f.read()
exec d

or

execfile "myModule"

For Python 3.xxx replace this code with:

exec(open("C:/PathToMyMacro/myMacro.FCMacro").read())

To share code across macros, you can access the FreeCAD or FreeCADGui module (or any other Python module) and set any attribute to it. This should survive the execution of the macro.

import FreeCAD
if hasattr(FreeCAD,"macro2_executed"):
    ...
else:
    FreeCAD.macro2_executed = True # you can assign any value because we only check for the existence of the attribute
    ... execute macro2

Starting with FreeCAD

Well, I think you now have a good idea of how Python works, and you can start exploring what FreeCAD has to offer. FreeCAD's Python functions are all well organized in different modules. Some of them are already loaded (imported) when you start FreeCAD. So, just do

dir()

and read on to FreeCAD Scripting Basics.

Of course, we saw here only a very small part of the Python world. There are many important concepts that we didn't mention. There are three very important Python reference documents on the net:

Be sure to bookmark them!



Написание сценариев Python в FreeCAD

FreeCAD построен с нуля, чтобы быть полностью контролируемым Python сценариями. Почти все части FreeCAD, такие как интерфейс, содержимое сцены, и даже представление этого содержания в окне 3D просмотра доступны из встроенного Python интерпретатора или из своих собственных сценариев. Как результат, FreeCAD вероятно, является одной из наиболее глубоко настраиваемый инженерных приложений, доступных сегодня.

В своем нынешнем состоянии однако, FreeCAD имеет очень мало "родных" команд для взаимодействовия с вашими 3D-объектами, в основном, потому что он все еще находится в ранней стадии развития, но и потому, что философски это больше платформа для развития САD, чем пользовательское приложение. Но простота сценариев на Python внутри FreeCAD, вероятно, поможет гораздо быстрее увидеть новые функциональные возможности, разрабатываемые "продвинутыми пользователями", или, как правило, пользователями, которые немного знают о Python программировании, как мы надеемся, у себя

Если вы не знакомы с Python, мы рекомендуем Вам искать учебники по интернету, и бегло взглянуть на его структуру. Python это очень простой язык для обучения, особенно потому, он может быть сразу запущен внутри интерпритатора, где и простая команда и готовая программа может быть выполнена "на лету", без необходимости компилировать что-либо. FreeCAD имеет встроенный в Python интерпритатор. Если вы не видите окно с надписью «Консоль Python», как показано ниже, вы можете активировать его через Вид → Панели → Консоль Python, чтобы вызвать интерпретатор.

Интерпретатор

В интерпретаторе , вы можете получить доступ к установленным в вашей системе модулям Python, а также встроенным модулям FreeCAD, и всем дополнительным модулям FreeCAD что вы установите позже. Скриншот ниже показывает, Python интерпретатор:

The FreeCAD Python interpreter

В интепритаторе, вы можете выполнять код Python и просматривать доступные классы и функции. FreeCAD предоставляет очень удобный браузер классов для освоения нового мира FreeCAD: Когда вы вводите имя известного класса после точки сразу же появляется (то есть вы хотите добавить что-то из этого класса), окно браузера, где вы можете перемещаться между имеющимися подклассами и методами. При выборе если существует, связанный текст справка, то он отображается:

The FreeCAD class browser

Таким образом, сначало наберите App. илиGui. посмотрите, что происходит. Другой, более общий Python метод изучения содержимого модулей и классов является использование команды dir(). Например, ввод print dir() выведет список всех модулей, загруженных в FreeCAD. print dir(App) покажет вам все, что содержит App модуль и.т.д.

Еще одна полезная особенность интерпритатора возможность вернуться назад по истории команд и извлечь строки кода, которые вы уже набрали ранее. Для перемещения по истории команд, просто используйте CTRL+UP или CTRL+DOWN.

Щелкнув правой кнопкой мыши в окне интерпритатора, у вас также есть несколько других опций, таких как копирование всей истории (полезно для эксперимента что-то сделать, а затем получить полный сценарий этого), или вставить имя файла с полным путем.

Python Help

В меню Help, вы найдете раздел "Automatic python modules documentation", при открытии которого откроется окно браузера, содержащего полную, создаваемую в реальном времени, документацию всех модулей Python, доступных в интерпретаторе FreeCAD, встроенных модулях Python и FreeCAD, установленных в систему модулей и дополнительные модулей FreeCAD. Доступна ли документация зависит от того, сколько усилий разработчик каждого модуля приложил к документированию своего кода, но, как правило Python модули имеют репутацию хорошо задокументированных. Ваше окно FreeCAD должно оставаться открытым для того чтобы система документации работала. В разделе «Помощь Python» находится ссылка на этот вики-раздел «User Hub».

Встроеные модули

С FreeCAD предназначена для запуска без графического интерфейса пользователя, почти все функциональные возможности разделены на две группы: Базовая функциональности, названные App, и Gui функциональность, названный Gui. Таким образом, наши два основных встроенных в FreeCAD модуля называются App и Gui. Эти два модуля можно также подключить из сценариев, вне интерпретатора, с соответствующими названиями FreeCAD и FreeCADGui.

  • В App модуле, вы найдете все, связанное с самим приложением, такие методы как открытия или закрытия файлов, а также документов, как настройка активного документа или объявление его содержания.
  • В Gui модуле, вы найдете инструменты для доступа и управления элементами графического интерфейса, такими как инструментарии и и их панели инструментов, и, что более интересно, графическое представление всего содержимого FreeCAD.

Список всего что содержиться в этих модулях - немного контрпродуктивная задача, поскольку они растут довольно быстро с развитием FreeCAD. Но два инструмента (класс браузер и Python help) для просмотра должны обеспечить вас, в любой момент, полной и актуальной документацией по этим модулям.

Объекты модулей App и Gui

Как мы уже говорили, в FreeCAD, всё разделенные между основным и представлением. Это включает в себя и 3D-объекты. Вы можете получить доступ определяющим свойствам объектов (одна из особенностей FreeCAD) с помощью модуля App, и измененить то, как они представлены на экране с помощью модуля Gui. Например, куб имеет свойства, которые определяют его, такие как ширина, длина, высота, они хранятся в App объекта, а представление свойств, таких как цвета граней, режим отрисовки, хранятся в соответствующем Gui объекте.

Этот способ обладает очень широким спектром применения, как с алгоритмами работы только с определеной частью функций, не нужно заботиться о какой-либо визуальной части, или даже перенаправления содержания документов не-графических приложений, таких как списки, таблицы или элементный анализ.

Для каждого App объекта в вашем документе, существует соответствующий объект Gui. Сам документ, собственно, также App и Gui объект. Это, конечно, действует только при запуске FreeCAD с полным интерфейсом. В режиме командной строки ,без графического интерфейса , доступны только App объекты. Обратите внимание, что часть Gui объектов создается снова каждый раз когдат App объект отмечен как "to be recomputed"[вольно:был пересчитан] (например, когда один из его параметров изменился), поэтому изменения, которые вы могли сделать непосредственно на Gui объекте, могут быть потеряны.

чтобы получить доступ к App части, введите:

myObject = App.ActiveDocument.getObject("ObjectName")

где "ObjectName это имя вашего объекта. Вы также можете ввести:

myObject = App.ActiveDocument.ObjectName

чтобы получить доступ к Gui части некоторого объекта, введите:

myViewObject = Gui.ActiveDocument.getObject("ObjectName")

где "ObjectName это имя вашего объекта. Вы также можете ввести:

myViewObject = App.ActiveDocument.ObjectName.ViewObject

If we have no GUI (for example we are in command line mode), the last line will return None. Если у нас нет графического интерфейса (например, мы находимся в режиме командной строки), последняя строка вернет None.

Объекты документа

В FreeCAD всё над чем вы работаете находится внутри документов. Документ содержит вашу геометрию и может быть сохранен в файл. Одновременно может быть открыто несколько документов. Документ, также как и геометрия, содержащиеся внутри него, имеет App и Gui части . App часть содержит вашу фактически определенную геометрию, в то время как Gui часть содержит различные отображения(views) вашего документа. Вы можете открывать несколько окон, каждое из которых отображение вашей работы с различным масштабом или точкой зрения. Эти виды являются входят в Gui часть вашего документа.

Чтобы получить доступ к App части текущего открытого (активного) документа, введите:

myDocument = App.ActiveDocument

Чтобы создать новый документ, введите:

myDocument = App.newDocument("Document Name")

Чтобы получить доступ к Gui части текущего открытого (активного) документа, введите:

myGuiDocument = Gui.ActiveDocument

чтобы получить доступ к текущему виду, введите:

myView = Gui.ActiveDocument.ActiveView

Использование дополнительных модулей

Модули FreeCAD и FreeCADGui отвечают за создание и управление объектами в документе FreeCAD. Они не занимаются созданием или изменением геометрии. Это потому, что эта геометрия может быть нескольких типов, и поэтому она управляется дополнительными модулями, каждый из которых отвечает за управление определенным типом геометрии. Например, Модуль Part использует ядро OpenCascade и поэтому может создавать и манипулировать геометрией типа B-rep, что и является предназначением OpenCascade. Модуль Mesh может создавать и модифицировать объекты типа сетка. Таким образом, FreeCAD может обрабатывать самые разные типы объектов, которые могут сосуществовать в одном документе, и новые типы могут быть легко добавлены в будущем.

Создание объектов

Каждый модуль имеет свой собственный способ обработки своей геометрии, но обычно они все могут создавать объекты в документе. Но документ FreeCAD также знает о доступных типах объектов, предоставляемых модулями:

FreeCAD.ActiveDocument.supportedTypes()

перечислит вам все возможные объекты, которые вы можете создать. Например, давайте создадим сетку (обработанную модулем Mesh) и деталь (обработанную модулем Part):

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

Первый аргумент - это тип объекта, второй - имя объекта. Наши два объекта выглядят почти одинаково: они еще не содержат никакой геометрии, и большинство их свойств одинаковы, когда вы проверяете их с помощью dir (myMesh) и dir (myPart). За исключением одного, myMesh имеет свойство «Mesh», а «Part» - свойство «Shape». Здесь хранятся данные Mesh и Part. Например, давайте создадим куб Part и сохраним его в нашем объекте myPart:

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

Вы можете попытаться сохранить куб в свойстве Mesh объекта myMesh, он вернет сообщение об ошибке неправильного типа. Это происходит из-за того, что эти свойства предназначены для хранения только определенного типа. В свойстве Mesh myMesh вы можете сохранять только то, что создано с помощью модуля 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.TypeId

или узнать, является ли объект производным от одного из базовых объектов (элемент детали, элемент сетки и т.д.):

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

Теперь вы действительно можете начать играть с FreeCAD! Чтобы узнать, что вы можете сделать с помощью Part Module, прочитайте страницу Part scripting или страницу Mesh Scripting для работы с Модуль Mesh. Обратите внимание, что хотя модули Part и Mesh являются наиболее полными и широко используемыми, другие модули, такие как Draft Module, также имеют API для написания скриптов, которые могут быть вам полезны. Полный список всех модулей и доступных инструментов см. в разделе Category:API.



Введение

Прежде всего вы должны импортировать Mesh модуль:

import Mesh

После этого вы получаете доступ к Mesh модулю и классам Mesh которые сообщаются с с функциями FreeCAD C++ Mesh-Kernel.

Создание и Загрузка

Чтобы создать простейший полигонный(сеточный) объект, просто используйте стандартный конструктор:

mesh = Mesh.Mesh()

Вы также можете создать объект из файла

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

Какие файловые форматы вы можете использовать для создания полигиональных объектов написано здесь.

Или создайте его из множества треугольников, задав их верщины:

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)
Mesh.show(planarMeshObject)

Mesh-Ядро заботится о создании топологического правильной структуры данных сортируя совпадающие точки и края вместе.

Позже вы увидете как можно протестировать и изучить полигиональные(сеточные) данные.

Моделирование

Для создания обычной геометрии вы можете использовать Python сценарий BuildRegularGeoms.py.

import BuildRegularGeoms

Этот сценарий предоставляет методы для определения простых тел вращения, таких как сферы, элипсоиды, цилиндры, тороиды и конусы. И он также обладает методом для создания простого куба. Чтобы создать тороид, например, следующим образом:

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

Первые два параметра определяют радиусы тороида а третий параметр фактор подвыборки , как много треугольников будет создано. Чем выше это значение тем сглаженней и наоброт чем ниже тем грубее тело. Mesh классы предоставляют набор логических функций которые могут быть использовыны в целях моделирования. Они обеспечивают объединение, пересечение и вычитание двух полигиональных объектов.

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 = 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.

See also Mesh API


Base ExampleCommandModel.png Руководство

Тема
Programming
уровень
Intermediate
Время для завершения
автор
FreeCAD версия
Пример файла (ов)



На этой странице описаны несколько методов создания и изменения Part shape из python. Перед прочтением этой страницы, если вы новичок в python, полезно прочитать о скриптинге на python и Как работает скриптинг на Python во FreeCAD.

Введение

Здесь мы объясним вам, как управлять Part Module непосредственно из интерпретатора Python FreeCAD или из любого внешнего сценария. Основы создания сценариев топологических данных описаны в Модуль Part, объяснение концепции. Обязательно просмотрите раздел Scripting и страницы Основы скриптинга FreeCAD, если вам нужна дополнительная информация о том, как работает python-скриптинг во FreeCAD .

Диаграмма Классов

Это Unified Modeling Language (UML) обзор наиболее важных классов модуля Part:

Python классы содержащиеся в модуле Part

Геометрия

Геометрические объекты являются строительными блоками для всех топологических объектов:

  • GEOM Базовый класс геометрических объектов
  • LINE Прямая линия в 3D, задается начальной и конечной точкой
  • CIRCLE Окружность или дуга задается центром, начальной и конечной точкой
  • ...... И вскоре еще немного

Топология

Доступны нижеследующие топологические типы данных:

  • COMPOUND Группа из топологических объектов любого типа.
  • COMPSOLID Составное твердое тело, как набор твердых тел соединенными гранями. Он расширяет понятие Ломаной кривой(WIRE) и оболочки(SHELL) для твердых тел.
  • SOLID Часть пространства ограниченная оболочкой. Она трехмерная.
  • SHELL Набор граней соединенных между собой через ребра. Оболочки могут быть открытыми или закрытыми.
  • FACE В 2D это часть плоскости; в 3D это часть поверхности. Это геометрия ограничена (обрезана) по контурам. Она двухмерная.
  • WIRE Набор ребер соединенных через вершины. Он может быть как открытым, так и закрытым в зависимости от того связаны ли крайние ребра или нет.
  • EDGE Топологический элемент соответствующий ограниченной кривой. Ребро как правило ограничивается вершинами. Оно одномерное.
  • VERTEX Топологический элемент соответствующий точке. Обладает нулевой размерность.
  • SHAPE общий термин охватывающий все выше сказанное.

Примеры: Создание простейшей топологии =

Wire


Теперь мы создадим топологию из геометрических примитивов. Для изучения мы используем деталь(part), как показано на картинке состоящую из четырех вершин, двух окружностей и двух линий.

Создание Геометрии

Cначала мы должны создать отдельную деталь из данной ломаной. И мы должны убедиться что вершины геометрических частей расположены на тех же позициях. В противном случае позже мы не смогли бы соединить геометрические части в топологию!

Итак, сначала мы создаем точки:

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)

Дуга

Circle


Для создания дугу окружности нам нужно создать вспомогательную точку и провести дугу через три точки:

VC1 = Base.Vector(-10,0,0)
C1 = Part.Arc(V1,VC1,V4)
# and the second one
VC2 = Base.Vector(40,0,0)
C2 = Part.Arc(V2,VC2,V3)

Линия

Line


Линия может быть очень просто создана из точек:

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

«Примечание: в FreeCAD 0.16 использовалась команда Part.Line, для FreeCAD 0.17 необходимо использовать Part.LineSegment»

Соединяем все вместе

Последний шаг - собираем все основные геометрические элементы вместе и получаем форму:

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

Создание призмы

Теперь вытягиваем ломанную по направлению и фактически получаем 3D форму:

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

Показать все

Part.show(P)

Создание основных фигур

Вы легко можете создать базовый топологический объект с помощью методов "make...()" содержащихся в модуле Part:

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

Доступные make...() методы:

  • makeBox(l,w,h,[p,d]) : создает прямоугольник, с началом в точке p и вытянутый в направлении d с размерами (l,w,h) По умолчанию p установлен как Vector(0,0,0) и d установлен как Vector(0,0,1)
  • makeCircle(radius,[p,d,angle1,angle2]) -- Создает окружность с заданным радиусом. По умолчанию p=Vector(0,0,0), d=Vector(0,0,1), angle1=0 и angle2=360
  • makeCone(radius1,radius2,height,[p,d,angle]) -- Создает конус с заданным радиусами и высотой. По умолчанию p=Vector(0,0,0), d=Vector(0,0,1) и angle=360
  • makeCylinder(radius,height,[p,d,angle]) -- Создает цилиндр с заданным радиусом и высотой. По умолчанию p=Vector(0,0,0), d=Vector(0,0,1) и angle=360
  • makeLine((x1,y1,z1),(x2,y2,z2)) -- Создает линию проходящую через две точки
  • makePlane(length,width,[p,d]) -- Создает плоскость с заданной длинной и шириной. По умолчанию p=Vector(0,0,0) и d=Vector(0,0,1)
  • makePolygon(list) -- Создает многоугольник из списка точек
  • makeSphere(radius,[p,d,angle1,angle2,angle3]) -- Создает сферу с заданным радиусом. По умолчанию p=Vector(0,0,0), d=Vector(0,0,1), angle1=0, angle2=90 и angle3=360
  • makeTorus(radius1,radius2,[p,d,angle1,angle2,angle3]) -- Создает тор по заданными радиусам.По умолчанию p=Vector(0,0,0), d=Vector(0,0,1), angle1=0, angle2=360 и angle3=360

На странице Part API приведен полный список доступных методов модуля Part.

Импорт необходимых модулей

Сначала нам нужно импортировать модуль Part, чтобы мы могли использовать его содержимое в python. Также импортируем модуль Base из модуля FreeCAD:

import Part
from FreeCAD import Base

Создание вектора

Векторы являются одними из самых важных частей информации при построении фигур. Они обычно содержат три числа (но не всегда): декартовы координаты x, y и z. Для создания вектора введите:

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

Мы только что создали вектор с координатами x = 3, y = 2, z = 0. В модуле Part векторы используются повсеместно. Формы детали также используют другой тип представления точек, называемый Vertex, который является просто контейнером для вектора. Вы можете получить доступ к вектору вершины следующим образом:

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

Как создать Ребро?

Ребра не что иное как линия с двумя вершинами:

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.LineSegment(vec1,vec2)
edge = line.toShape()

Вы можете узнать длину и центр ребра, вот так:

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

Вывод фигуры на экран

До сих пор мы создали объект ребро, но не увидели его на экране. Это связано с тем, что 3D-сцена FreeCAD отображает только то, что указано для отображения. Для этого мы используем этот простой метод:

Part.show(edge)

Функция show создает объект "shape" в нашем 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 будет создана на расстоянии 10 от начала координат x и будет направлена вдоль оси 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 или используя math модуль python-а (прежде, конечно, выполнив import math): degrees = math.degrees(radians)

degrees = math.degrees(radians)

Как создать Дугу по точкам?

К сожалению нет функции makeArc, но у нас есть функция Part.Arc для создания дуги через три точки. Она создает объект дуги, соединяющий начальную точку с конечной точкой через среднюю точку. Функция .toShape() объекта дуги должна вызываться для получения объекта ребра, так же, как при использовании Part.LineSegment вместо Part.makeLine.

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(circle,0,pi)

Дуги являются действительными ребрами, такими как линии, поэтому их можно использовать и в ломаных линиях.

Как создать многоугольник или линию по точкам?

Линия по нескольким точкам, не что иное как создание ломаной с множеством ребер. функция makePolygon берет список точек и создает ломанную по этим точкам:

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

Creating a Bézier curve

Bézier curves are used to model smooth curves using a series of poles (points) and optional weights. The function below makes a Part.BezierCurve from a series of FreeCAD.Vector points. (Note: when "getting" and "setting" a single pole or weight, indices start at 1, not 0.)

def makeBCurveEdge(Points):
   geomCurve = Part.BezierCurve()
   geomCurve.setPoles(Points)
   edge = Part.Edge(geomCurve)
   return(edge)

Как создать плоскость?

Плоскасть это ровная поверхность, в смысле 2D грань 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) создат плоскость нормальную к оси х:

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). Здесь толщинаhe BoundBoxпо оси y равна нулю.

примечание: makePlane доступны только Base.Vector() для задания start_pnt и dir_normal а не кортежи

Как создать эллипс?

Создать эллипс можно несколькими путями:

Part.Ellipse()

Создает эллипс с большой полуосью 2 и малой полуосью 1 с центром в (0,0,0)

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 и center. Аналогично Дуге, Эллипс также создает объект, а не ребро, так что мы должны превратить его в ребро используя toShape() для отображения

Примечание: Дуга допускает только Base.Vector() для задания точек, а не кортеж.

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

Для верхнем конструкторе Эллипса мы ввели center, 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)

В приведенном выше коде, создан полу тор, изменен только последний параметр т.е. angle а остальные углы установлены по умолчанию.

Подстановка угла 180 создаст тор от 0 до 180 т.е. половину

Как создать блок или паралелепипед?

makeBox(length,width,height,[pnt,dir]) -- Создает блок расположенный в pnt с размерами (length,width,height)

По умолчанию 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)

Modifying shapes

There are several ways to modify shapes. Some are simple transformation operations such as moving or rotating shapes, others are more complex, such as unioning and subtracting one shape from another.

Transform operations

Translating a shape

Translating is the act of moving a shape from one place to another. Any shape (edge, face, cube, etc...) can be translated the same way:

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

This will move our shape "myShape" 2 units in the x direction.

Rotating a shape

To rotate a shape, you need to specify the rotation center, the axis, and the rotation angle:

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

The above code will rotate the shape 180 degrees around the Z Axis.

Generic transformations with matrixes

A matrix is a very convenient way to store transformations in the 3D world. In a single matrix, you can set translation, rotation and scaling values to be applied to an object. For example:

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

Note: FreeCAD matrixes work in radians. Also, almost all matrix operations that take a vector can also take three numbers, so these two lines do the same thing:

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

Once our matrix is set, we can apply it to our shape. FreeCAD provides two methods for doing that: transformShape() and transformGeometry(). The difference is that with the first one, you are sure that no deformations will occur (see "scaling a shape" below). We can apply our transformation like this:

myShape.transformShape(myMat)

or

myShape.transformGeometry(myMat)

Scaling a shape

Scaling a shape is a more dangerous operation because, unlike translation or rotation, scaling non-uniformly (with different values for x, y and z) can modify the structure of the shape. For example, scaling a circle with a higher value horizontally than vertically will transform it into an ellipse, which behaves mathematically very differently. For scaling, we can't use the transformShape, we must use transformGeometry():

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

Логические Операции

Как вырезать одну форму из других?

cut(...) - Вычисление различий задано в топологическом классе shape.

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)

Как получить пересечение двух форм?

common(...) - Пересечение задано в топологическом классе shape

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)

Как объединить две формы?

fuse(...) - Объединение задано в топологическом классе shape

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)

Как получить сечение тела и заданой формы?

section(...) - Сечение задано в топологическом классе shape.

Вернет секущую кривую, состоящую из ребер

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>]

Extrusion

Extrusion is the act of "pushing" a flat shape in a certain direction, resulting in a solid body. Think of a circle becoming a tube by "pushing it out":

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

If your circle is hollow, you will obtain a hollow tube. If your circle is actually a disc with a filled face, you will obtain a solid cylinder:

wire = Part.Wire(circle)
disc = Part.Face(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 тела, содержит грани. Грани, всегда содержат ломанные, которые являются набором ребер ограничивающих грань. Каждая грань обладает ровно одной замкнутой ломаной. В ломанной, мы можем посмотреть на отдельно на каждое ребро, и по краям каждого ребра , мы можем увидеть вершины. Очевидно, что прямые ребра обладают только двумя вершинами. Вершины модуля Part являются OCC(OpenCascade) формами, но они обладают атрибутом Point который возвращает FreeCAD вектор.

Исследование Рёбер

В случае ребра, которое является произвольной кривой, вы наверняка захотите произвести дискретизицию. В FreeCAD ребра задаются с помощью параметра длинны. Это означает что вы можете перемещатся вдоль ребра/кривой задавая длинну:

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

Теперь вы получить доступ ко всем свойствам ребра, с помощью длинны или позиции. Это означает, что у ребра в 100mm длинной, начальная позиция это 0 а конечная это 100.

anEdge.tangentAt(0.0)      # tangent direction at the beginning
anEdge.valueAt(0.0)        # Point at the beginning
anEdge.valueAt(100.0)      # Point at the end of the edge
anEdge.derivative1At(50.0) # first derivative of the curve in the middle
anEdge.derivative2At(50.0) # second derivative of the curve in the middle
anEdge.derivative3At(50.0) # third derivative of the curve in the middle
anEdge.centerOfCurvatureAt(50) # center of the curvature for that position
anEdge.curvatureAt(50.0)   # the curvature
anEdge.normalAt(50)        # normal vector at that position (if defined)

Использование выделения(выбора)

Здесь мы увидим как можно использовать "выделение", которое пользователь сделал в программе просмотра. прежде всего мы создадим блок и отобразим его в окне просмотра

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 Getting Started Page можно узнать как построить бутыль. Также это отличный пример для 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.LineSegment(aPnt1,aPnt2)
   aSegment2=Part.LineSegment(aPnt4,aPnt5)
   aEdge1=aSegment1.toShape()
   aEdge2=aArcOfCircle.toShape()
   aEdge3=aSegment2.toShape()
   aWire=Part.Wire([aEdge1,aEdge2,aEdge3])
   
   aTrsf=Base.Matrix()
   aTrsf.rotateZ(math.pi) # rotate around the z-axis
   
   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.makeFillet(myThickness/12.0,myBody.Edges)
   
   return myBody

el = makeBottle()
Part.show(el)

Подробные объяснения

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.LineSegment(aPnt1,aPnt2)
   aSegment2=Part.LineSegment(aPnt4,aPnt5)

Здесь мы фактически задаём геометрию: дугу, созданую по 3 точкам, и два линейных сегменты, созданные по 2 точкам.

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])

На данный момент мы построили только половину сечения. Проще, чем строить таким же образом целое сечение, мы можем просто отразить то что мы сделали и склеить две половинки. Сначала создадим матрицу(Нео ау). Матрица является распространенным способом произвести изменения над объектом в 3D пространстве, также она может содержать в одной структуре все базовые преобразования которые позволяют 3D объекты(перемещение, вращение и масштабирование). Здесь , после создания матрицы, мы отражаем её и создаем копию нашеё ломанной, применя к ней преобразование матрицой. Теперь мы получили две ломанные и мы можем создать из них третью ломаную, так как ломанные это всего лишь список ребер.

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

Теперь мы получаем нашу твердотельную Деталь как результат нашей функции. Это Деталь - твердотельная, как и любая другая Деталь форма, может быть свзана с объектом в документе FreeCAD, с помошью:

el = makeBottle()
Part.show(el)

или , ещё проще:

Box pierced

Here is a complete example of building a pierced box.

The construction is done one side at a time; when the cube is finished, it is hollowed out by cutting a cylinder through it.

import Draft, Part, FreeCAD, math, PartGui, FreeCADGui, PyQt4
from math import sqrt, pi, sin, cos, asin
from FreeCAD import Base

size = 10
poly = Part.makePolygon( [ (0,0,0), (size, 0, 0), (size, 0, size), (0, 0, size), (0, 0, 0)])

face1 = Part.Face(poly)
face2 = Part.Face(poly)
face3 = Part.Face(poly)
face4 = Part.Face(poly)
face5 = Part.Face(poly)
face6 = Part.Face(poly)
     
myMat = FreeCAD.Matrix()
myMat.rotateZ(math.pi/2)
face2.transformShape(myMat)
face2.translate(FreeCAD.Vector(size, 0, 0))

myMat.rotateZ(math.pi/2)
face3.transformShape(myMat)
face3.translate(FreeCAD.Vector(size, size, 0))

myMat.rotateZ(math.pi/2)
face4.transformShape(myMat)
face4.translate(FreeCAD.Vector(0, size, 0))

myMat = FreeCAD.Matrix()
myMat.rotateX(-math.pi/2)
face5.transformShape(myMat)

face6.transformShape(myMat)               
face6.translate(FreeCAD.Vector(0,0,size))

myShell = Part.makeShell([face1,face2,face3,face4,face5,face6])   

mySolid = Part.makeSolid(myShell)
mySolidRev = mySolid.copy()
mySolidRev.reverse()

myCyl = Part.makeCylinder(2,20)
myCyl.translate(FreeCAD.Vector(size/2, size/2, 0))

cut_part = mySolidRev.cut(myCyl)

Part.show(cut_part)

Загрузка и Сохранение

Есть несколько путей чтобы сохранения вышей работы в Part модули. Вы конечно можете сохранить ваш FreeCAD документ, а также вы можете сохранить Part(Деталь) объект напрямую в обычные CAD форматы, такие как BREP, IGS, STEP и STL.

Сохраненить форму в файл , легко. Есть доступные для всех форм методы exportBrep(), exportIges(), 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")

To convert an .stp file to an .igs file:

import Part
 s = Part.Shape()
 s.read("file.stp")       # incoming file igs, stp, stl, brep
 s.exportIges("file.igs") # outbound file igs

Примечание этот импорт или открытие BREP, IGES or STEP файлов также можно сделать напрямую с помощью меню File -> Open or File -> Import. На данный момент экспорт ещё не включен, но будет там в ближайшее время.



Преобразование Part объектов в Полигиональную сетку

Конвертация высоко-уровневых объектов, таких как формы Part(Деталей) в простые объекты такие как полигиональные сетки это довольно простая операция, когда все грани Детали разбиваются на треугольники . Результат этой триангуляции затем используется для построения сетки:

#let's assume our document contains one part object
import Mesh
faces = []
shape = FreeCAD.ActiveDocument.ActiveObject.Shape
triangles = shape.tessellate(1) # the number represents the precision of the tessellation)
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 объект

Преобразование полигиональной сетки в Деталь черезвычайно важная операция в работе CAD, потому что очень часто вы получаете, от других людей или на выходе из других приложений, 3D данные в полигиональном виде. Сетки это очень практичны для представления геометрии свободной формы и больших визуальных сцен, так как они очень легковесны, но в CAD мы в основном предпочитаем высокоуровневые объекты, которые несут гораздо больше информации, таких как идеии твердых тел, или грани созданой из кривых а не труегольников.

Преобразование сетки в высокоуровневый объект (занимается в FreeCAD Модуль Деталей) это не простая операция. Сетки могут состоять из тысяч треугольников (например когда, сгенерированы 3D сканером), и телом состоящим из того же числа граней, будет черезвычайно сложно управлять. Поэтому вы хотите оптимизировать объект при преобразовании.

В настоящее время FreeCAD предлагает два метода для преобразования Полигиональной Сетки в Деталь. Первый метод прост, это прямое преобразование, без какой либо оптимизации:

import Mesh,Part
mesh = Mesh.createTorus()
shape = Part.Shape()
shape.makeShapeFromMesh(mesh.Topology,0.05) # the second arg is the tolerance for sewing
solid = Part.makeSolid(shape)
Part.show(solid)

Второй метод позволяет учитывать какие грани сетки компланарны, когда угол между ними принимает определенное значение. Это позволяет строить формы попроще:

# let's assume our document contains one Mesh object
import Mesh,Part,MeshPart
faces = []
mesh = App.ActiveDocument.ActiveObject.Mesh
segments = mesh.getPlanes(0.00001) # use rather strict tolerance here
 
for i in segments:
  if len(i) > 0:
     # a segment can have inner holes
     wires = MeshPart.wireFromSegment(mesh, i)
     # we assume that the exterior boundary is that one with the biggest bounding box
     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)
        # all interior wires mark a hole and must reverse their orientation, otherwise Part.Face fails
        for i in wires:
           i.reverse()

        # make sure that the exterior wires comes as first in the list
        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)
Arrow-left.svg Previous: Mesh to Part
Next: Pivy Arrow-right.svg

Геометрия которая появляется в 3D видах FreeCAD получается с помощью библиотек Coin3D. Coin3D это реализация стандарта OpenInventor . OpenCascade тоже поддерживает схожую функциональность, но было решено при создании FreeCAD, не использовать встроеный в openCascade просмотрщик и скорее перейти на более производительный coin3D.

OpenInventor на самом деле язык описания 3D сцены. Сцена описанная в openInventor затем отрисовывается OpenGL на вашем экране. Coin3D заботит об этом, поэтому программисту не надо иметь дело со сложными вызовами openGL, он просто должен предоставить корректный(работающий)OpenInventor код. Большим преимуществом является то что openInventor это широко известны и хорошо задокументированный стандарт.

Одну из главных работ, которую FreeCAD делает за вас, в основном это перевод информации о openCascade геометрии в формат языка openInventor.

OpenInventor записывает трехмерную сцену в форме древа сцен, как показано ниже:

Scenegraph.gif рисунок с сайта 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 {
       }
    }
}

Как вы можете видеть, его структура проста. Вы используете разделители(separator) организуя ваши данные в блоки, это немного похоже на то как вы организуете ваши файлы в папках. Каждый оператор влияет на то что будет дальше, например, первые два пункта в ваншем корневом разделителе это поворот и перенос(трансляция), как они повлияют на следующий элемент, котоорый тоже является резделителем. В этом сепараторе, материал определяется, и другого преобразования. Поэтому наш цилиндр будет подвержин обеим трансормациям, то что было применено непосредственно к нем, так и то что было применено к родительскому разделителю.

Мы также обладаем множество элементов других типов , для организации нашей сцены, таких как группы, переключатели и анотации.Мы можем задать очень сложные материалы для ваших объектов, с цветом, текстурой, теневыми режимами и прозрачностью. Мы также можем задать освещение, камеры, и даже движение. Можно даже встроить кусочки сценариев в openInventor файлы, для задания более сложного поведения.

Если вы заинтересованы в получении дополнительной информации о openInventor, отпраляйтесь напрямую к самому известному руководству Inventor mentor.

В FreeCAD, как правило. не нужно напрямуюю взаимодействовать с древом сцен openInventor. Каждый объект в документе FreeCAD, будь то полигиональная модель(mesh), форма детали или что-нибудь ещё, автоматически преобразуется в openInventor код и вставляется в основное дерево сцен которое вы видите в окне 3D просмотра. Это древо сцен непрерывно обновляется, когда вы делает изменения, добавляете или удаляете объекты из документа. В самом деле каждый объект (в пространстве App) обладает , поставщиком визуального отображения (соответствующий объект в пространстве Gui), ответственного за выдачу openInventor кода.

Но есть множество преимуществ, которые будут возможны при прямом доступе. Например, мы временно можем изменить внешний вид объекты, или мы можем добавить в сцену объекты, которые не обладают реальным представлением в документе FreeCAD, такие как геометрия построений, помощники, графические подсказки или инструменты , такие как манипуляторы или отображающаяся на экране информация.

FreeCAD обладает несколькими инструментами для просмотра и изменения openInventor кода. На пример, нижеследующий код на python отобразит openInventor представление выбранного объекта:

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

А также мы обладаем модулем python открывает полный доступ к управлению чем угодно в Coin3D, такому как ваше дерево сцен в FreeCAD. Также читайте об этом на странице Pivy.


Pivy это python библаотека привязанная к Coin3d, библиотека 3D-рендеринга, используемая во FreeCAD. Когда он импортирован, в запущенный python интерпритатор, он позволяет вести диалог напрямую с любым запущеным деревом сцен Coin3d, также как окна трехмерного отображения FreeCAD, или даже создавать новые. Pivy входит в стандвртную установку FreeCAD.

Библиотека coin разделена на несколько частей, собственно coin, для управления древами сцен и привязки к различным GUI системам, таким как windows или, в нашем случае, qt. Эти модули также доступны pivy, если они представлены в системе. Модуль coin всегда присутствует, и это то что мы будем использовать в любом случае, поэтому мы не должны хаботится о наших привзках нашего 3D отображения, к различным интерфейсам, это уже сделано в самом FreeCAD. Все что вам нужно, так это сделать ЭТО:

from pivy import coin

Получение доступа и изменение древа сцен

Мы говорили на странице Scenegraph как организована типичная Coin сцена. Все что добавляется в окно трехмерного отображения FreeCAD , coin scenegraph, организует схожим образом. у нас есть один корневой узел, и все объекты на экране его потомки.

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 позаботится обо всем. Вы можете что-то в ваше древо сцен, изменить свойства, скрыть этот объект, показать временный объект, что угодно. Конечно это касается только отображения трехмерного вида. Это отображение получается при считывании 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)
myCustomNode.addChild(trans)
myCustomNode.addChild(cub)
sg.addChild(myCustomNode)

Помните, что в дереве сцен openInventor, важен порядок. Узел влияет на то что будет дальше, вы можете сказать нечто вроде: цет красны, куб, цвет желтый, сфера, и вы получите красный куб и желтую сферу. Если мы добавим перемещение сейчас в нашу существующий узел, он будет стоять после куба и не будет влиять на него. Если мы вставили его до его создания, как показано выше, мы могли бы сейчас сделать:

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 , ещё не обладает надлежащей документацией, но так как это точный перевод coin на Python, вы можете смело использовать документацию по coin как введение и используя стиль python вместо c++ стиля (например SoFile::getClassTypeId() в pivy будет SoFile.getClassId())

In C++:

SoFile::getClassTypeId()

In Pivy

SoFile.getClassId()


PySide

PySide это привязка Python кросс-платформенного инструментария GUI Qt. FreeCAD использует PySide для всех целей GUI (графический интерфейс пользователя) внутри Python. PySide является альтернативой пакету PyQt, который ранее использовался FreeCAD для своего графического интерфейса. PySide имеет более допустимую лицензию. Увидеть Differences Between PySide and PyQt для получения дополнительной информации о различиях.

Пользователи FreeCAD часто добиваются всего, используя встроенный интерфейс. Но для пользователей, которые хотят настроить свои операции, существует интерфейс Python, который описан в Python Scripting Tutorial. Интерфейс Python для FreeCAD обладает большой гибкостью и мощью. Для взаимодействия с пользователем Python с FreeCAD использует PySide, что описано на этой странице.

Python предлагает оператор 'print', который дает код:

print 'Hello World'

С оператором 'print' Python вы имеете только ограниченный контроль над внешним видом и поведением. PySide предоставляет отсутствующий элемент управления, а также обрабатывает среды (такие как среда макрофайловых файлов FreeCAD), где встроенных средств Python недостаточно.

Возможности PySide варьируются от:

PySideScreenSnapshot1.jpg

до:

PySideScreenSnapshot2.jpg

Familiarize yourself with some real-world examples of PySide

They divide the subject matter into 3 parts, differentiated by level of exposure to PySide, Python and the FreeCAD internals. The first page has overview and background material giving a description of PySide and how it is put together while the second and third pages are mostly code examples at different levels.

The intention is that the associated pages will provide simple Python code to run PySide so that the user working on a problem can easily copy the code, paste it into their own work, adapt it as necessary and return to their problem solving with FreeCAD. Hopefully they don't have to go chasing off across the internet looking for answers to PySide questions. At the same time this page is not intended to replace the various comprehensive PySide tutorials and reference sites available on the web.


Кроме стандартных типов объектов таких как аннотации, полигиональные сетки и детали, FreeCAD также предлагает удивительные возможности для создания 100% сценарных объектов, названые Python Функционалы(Python Features). Эти объекты будут вести себя точно так же как и любой другой FreeCAD объект, могут быть сохранены в документе и открыты на любом другом компьютере с установленным FreeCAD, так как python код определяющий этот объект также сохраняется в документе.

Python Функционалы следуют тому же правилу что и все FreeCAD Функционалы: они разделены на App и GUI части. App часть, Документированный Объект(Document Object), определяет геометрию нашего объекта, тогда как его GUI часть, Визуальное Представление Объекта(View Provider Object), определяет как объект будет отрисован на экране. Визуальное Представление Объекта, как и любой другой FreeCAD функционал, доступно только когда если вы запустили FreeCAD с его собственным GUI. Есть несколько свойств и методов доступных для создания вашего объекта. Свойства должны быть любыми Свойства должны быть любыми предопределенные типами свойств которые предлагает FreeCAD, и они появятся в окне отображающим свойства, так что они могут быть отредактированы пользователем. Таким образом, Python Функционалы являются истинно и полностью параметрическими. вы можете отдельно задать свойства Документированного и Визуального Объектов.

Python Features follow the same rule as all FreeCAD features: they are separated into App and GUI parts. The app part, the Document Object, defines the geometry of our object, while its GUI part, the View Provider Object, defines how the object will be drawn on screen. The View Provider Object, as any other FreeCAD feature, is only available when you run FreeCAD in its own GUI. There are several properties and methods available to build your object. Properties must be of any of the predefined properties types that FreeCAD offers, and will appear in the property view window, so they can be edited by the user. This way, FeaturePython objects are truly and totally parametric. you can define properties for the Object and its ViewObject separately.

Hint: In former versions we used Python's cPickle module. However, this module executes arbitrary code and thus causes a security problem. Thus, we moved to Python's json module.

Простой пример

Следующий пример можно найти в 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(float(l),float(w),float(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 json module.\
                Since we have some un-serializable parts here -- the Coin stuff -- we must define this method\
                to return a tuple of all serializable objects or None.'''
        return None
 
    def __setstate__(self,state):
        '''When restoring the serialized object from document we have the chance to set some internals here.\
                Since no data were serialized nothing needs to be done here.'''
        return None


def makeBox():
    FreeCAD.newDocument()
    a=FreeCAD.ActiveDocument.addObject("App::FeaturePython","Box")
    Box(a)
    ViewProviderBox(a.ViewObject)

makeBox()

Доступные свойства

Свойства это действительные строительные камни(не вспомнил замену) Python Функционалов. Через них, пользователь может взаимодествовать с объектом и изменять его. После создания нового Python Функционала в вашем документе ( a=FreeCAD.ActiveDocument.addObject("App::FeaturePython","Box") ),вы можете получить список доступных свойств, использовав:

obj.supportedProperties()

Вы получите список доступных свойств:

App::PropertyBool
App::PropertyBoolList
App::PropertyFloat
App::PropertyFloatList
App::PropertyFloatConstraint
App::PropertyQuantity
App::PropertyQuantityConstraint
App::PropertyAngle
App::PropertyDistance
App::PropertyLength
App::PropertySpeed
App::PropertyAcceleration
App::PropertyForce
App::PropertyPressure
App::PropertyInteger
App::PropertyIntegerConstraint
App::PropertyPercent
App::PropertyEnumeration
App::PropertyIntegerList
App::PropertyIntegerSet
App::PropertyMap
App::PropertyString
App::PropertyUUID
App::PropertyFont
App::PropertyStringList
App::PropertyLink
App::PropertyLinkSub
App::PropertyLinkList
App::PropertyLinkSubList
App::PropertyMatrix
App::PropertyVector
App::PropertyVectorList
App::PropertyPlacement
App::PropertyPlacementLink
App::PropertyPlacementList
App::PropertyColor
App::PropertyColorList
App::PropertyMaterial
App::PropertyPath
App::PropertyFile
App::PropertyFileIncluded
App::PropertyPythonObject
Part::PropertyPartShape
Part::PropertyGeometryList
Part::PropertyShapeHistory
Part::PropertyFilletEdges
Sketcher::PropertyConstraintList

При добавлении новых свойств к пользовательским объектам, позаботьтесь об этом:

  • Не используйте символы "<" или ">" в описании свойств (это вызовет поломку xml части .fcstd файла)
  • Свойства хранятся в .fcstd файле в алфавитном порядке. Если у вас есть форма(shape) в ваших свойствах, любое свойство имя которого идет, в алфавитном порядке, после "Shape" , будет загружено ПОСЛЕ формы, что может привести к странному поведению.

A complete list of property attributes can be seen in the PropertyStandard C++ header file. For instance, if you want to allow the user to enter only a limited range of values (e.g. using PropertyIntegerConstraint), in Python you will assign a tuple containing not only the property value, but also the lower and upper limit as well as the stepsize, as below:

prop = (value, lower, upper, stepsize)

Property Type

By default the properties can be updated. It is possible to make the properties read-only, for instance in the case one wants to show the result of a method. It is also possible to hide the property. The property type can be set using

obj.setEditorMode("MyPropertyName", mode)

where mode is a short int that can be set to:

 0 -- default mode, read and write
 1 -- read-only
 2 -- hidden

The EditorModes are not set at FreeCAD file reload. This could to be done by the __setstate__ function. See http://forum.freecadweb.org/viewtopic.php?f=18&t=13460&start=10#p108072. By using the setEditorMode the properties are only read only in PropertyEditor. They could still be changed from python. To really make them read only the setting has to be passed directly inside the addProperty function. See http://forum.freecadweb.org/viewtopic.php?f=18&t=13460&start=20#p109709 for an example.

Using the direct setting in the addProperty function, you also have more possibilities. In particular, an interesting one is mark a property as an output property. This way FreeCAD won't mark the feature as touched when changing it (so no need to recompute).

Example of output property (see also https://forum.freecadweb.org/viewtopic.php?t=24928):

obj.addProperty("App::PropertyString","MyCustomProperty","","",8)

The property types that can be set at last parameter of the addProperty function are:

 0 -- Prop_None, No special property type
 1 -- Prop_ReadOnly, Property is read-only in the editor
 2 -- Prop_Transient, Property won't be saved to file
 4 -- Prop_Hidden, Property won't appear in the editor
 8 -- Prop_Output, Modified property doesn't touch its parent container
 16 -- Prop_NoRecompute, Modified property doesn't touch its container for recompute


You can find these different property types defined in the source code C++ header for PropertyContainer

Другие примеры по сложней

Этот пример использует Модуль Деталей для создания октаэдра, задем создает собственное coin представление с помощью pivy.

Сначала сам Документированный Объект:

import FreeCAD, FreeCADGui, Part
import pivy
from pivy import coin

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 сцене:

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

Наконец, когда определен наш объект и его визуальный объект, нам просто нужно вызвать их:

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

Создание выделяемых объектов

Если вы хотите чтобы ваш объект можно было выбрать, или покрайней мере его частьt, щелкнув по нему в окне, вы должны включить его coin геометрию внутрь узла 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)

Просто, создайтеa узел SoFCSelection, затем добавте к нему узлы вашей геометрии, после добавте его к вашему главному узлу, вместо добавления напрямую всех ваши узлов геометрии.

Работа с простыми формами

Если ваш параметрический объект просто выводит форму, вам не нужно импользовать объект визуального представления. форма будет отображена используя стандартное FreeCAD-ое представление форм :

import FreeCAD as App
import FreeCADGui
import FreeCAD
import Part
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()

Same code with use ViewProviderLine

import FreeCAD as App
import FreeCADGui
import FreeCAD
import Part

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(100,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)

class ViewProviderLine:
   def __init__(self, obj):
      ''' Set this object to the proxy object of the actual view provider '''
      obj.Proxy = self

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

a=FreeCAD.ActiveDocument.addObject("Part::FeaturePython","Line")
Line(a)
ViewProviderLine(a.ViewObject)
App.ActiveDocument.recompute()

- Python object attributes lost at load

- New FeaturePython is grey

- Eigenmode frequency always 0?

- how to implement python feature's setEdit properly?

In addition to the examples presented here have a look at FreeCAD source code src/Mod/TemplatePyMod/FeaturePython.py for more examples.



FreeCAD обладает удивительной способность , импортироваться как python модуль в другие программы или в автономную python консоль, вместе со всеми модулями и компонентами. Можно даже импортировать FreeCAD GUI как python модуль --однако, с некоторыми ограничениями some restrictions.

Использование FreeCAD без GUI

Одно из первых, простых, прямой и полезных приложений , вы можете создать чтобы импортировать FreeCAD документы в ващу программу. В следующем примере, мы импортируем Part геометрию FreeCAD документа в blender. Это готовый сценарий. Я надеюсь вы будете поражены его простотой:

FREECADPATH = '/opt/FreeCAD/lib' # path to your FreeCAD.so or FreeCAD.dll file
import Blender, sys
sys.path.append(FREECADPATH)
 
def import_fcstd(filename):
   try:
       import FreeCAD
   except ValueError:
       Blender.Draw.PupMenu('Error%t

Сперва, вожно убедится что python найдет ваши FreeCAD библиотеки. как только он их найдет, все модули FreeCAD такие как Part, которые мы также будем использовать, будут доступны автоматически. Так что мы просто берес значение переменной sys.path, где описано где python ищет модули, и мы добавляем буть к библиотекам FreeCAD. Это изменение носит временный характер, и будет потеряно когдв мы закроем наш python интепритатор. Другой способ которым вы можете создать ссылку на вашу FreeCAD библиотеку в одном посковых путей python. Я держал путь в константе (FREECADPATH) так что бы было легче другому пользователю сценария настроить его под свою систему.

После того как мы проверили что библиотеки загружены (повторите/исключите последовательность), теперь мы можем работать с FreeCAD, так же как если бы мы были внутри FreeCADовского python интерпритатора. Мы открываем FreeCAD документ который передается нам с помощью функции main() , и мы создаем список список своих объектов. Затем, так как мы решаем заботиться только о геометрии детали «Part», мы проверяем, содержит ли свойство Type каждого объекта «Part», и затем тесселяем ее.

Трансляция(tesselation- преобразование в сетку) произвела список вершин и список граней, заданных индексами вершин.Это идеальный вариант, так как он точно аналогично блендеру задает сетки. Таким образом, наша задача до смешного проста, мы просто добавим оба списка содержащих вершины и грани в блендере сетку. Когда все будет сделано, мы просто перерисуем экран, и вот оно!

Конечно этот сценарий очень прост (в действительности я создал более продвинутый здесь), вы можете продолжить его, например импортирвав также полигиональные объекты, или импортировав Part геометрию которая не обладает гранями, или импортировав другие файловые форматы которые может читать FreeCAD. Вы также можете экспортировать геометрию в FreeCAD документ, что можно сделать схожим образом. Вы также можете создать диолог, где пользователь может выбрать что импортировать и.т.д... Красота всего этого заключается в том, что вы позволяете FreeCAD делать фоновую работу вто время как его результаты представляются в программе по вашему выбору.

Использование FreeCAD с GUI

Начиная с версии 4.2, Qt обладает интегрирующей способностью встраивать Qt-GUI-зависящие плагины в не-Qt главные приложения и распространять как привязки к главному приложению.

В особенности, для FreeCAD это означает что он может быть импортирован из другого приложения со всем его интерфейсом где головное приложение имеет полный контроль над FreeCAD, тогда.

Весь python код , для достижения этого, укладывается всего в две строчки

import FreeCADGui 
FreeCADGui.showMainWindow()

Если головное приложение основывается на Qt, то это решение должно работать на всех платформах поддерживаемых Qt. Однако, головное приложение должно ссылаться на туже версию Qt что и FreeCAD потому что иначе мы може столкнуться с неожиданными ошибками во время выполнения.

Однако,Для не-Qt преложений, имеется несколько ограничений , вы должны знать об этом. Это решение , вероятно не сработает вместе с остальными инструментальными средствами. Для Windows это работает до тех пор пока головное приложение напрямую основано на Win32 или любом другом инструментальном средстве который внутренне использует Win32 API такие как wxWidgets, MFC или WinForms. Для того чтобы заставить его работать под X11, головное предложение необходимо связать с библиотекой "glib".

Обратите внимание, для любого консольного приложения это решение, конечно, не работает, потому что не существует запущенного цикла обработки событий.

Caveats

Although it is possible to import FreeCAD to an external Python interpreter, this is not a common usage scenario and requires some care. Generally, it is better to use the Python included with FreeCAD, run FreeCAD via command line, or as a subprocess. See Start up and Configuration for more on the last two options.

Since the FreeCAD Python module is compiled from C++ (rather than being a pure Python module), it can only be imported from a compatible Python interpreter. Generally this means that the Python interpreter must be compiled with the same C compiler as was used to build FreeCAD. Information about the compiler used to build a Python interpreter (including the one built with FreeCAD) can be found as follows:

>>> import sys
>>> sys.version
'2.7.13 (default, Dec 17 2016, 23:03:43) \n[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.42.1)]'


Base ExampleCommandModel.png Руководство

Тема
Python
уровень
Beginner
Время для завершения
автор
FreeCAD версия
Пример файла (ов)


Эта страница содержит примеры, обрывки, куски FreeCAD python кода, собранный для получения пользователями оптыта и обсуждения на форумах. Читайте и используете их как начало для ваших собственных сценариев...

Обычный файл InitGui.py

Каждый модуль должен содержать, помимо основного файла модуля, файл InitGui.py , ответственного за вставку модуля в главное Gui. Это простой пример

class ScriptWorkbench (Workbench): 
    MenuText = "Scripts"
    def Initialize(self):
        import Scripts # assuming Scripts.py is your module
        list = ["Script_Cmd"] # That list must contain command names, that can be defined in Scripts.py
        self.appendToolbar("My Scripts",list) 
        
Gui.addWorkbench(ScriptWorkbench())

Обычный файл модуля

Это пример головного файла модуля, содержащего всё что ваш модуль делает. Это Scripts.py файл вызванный в предыдущем примере. Вы можете установить здесь все ваши пользовательские команды.

import FreeCAD, FreeCADGui 
 
class ScriptCmd: 
   def Activated(self): 
       # Here your write what your ScriptCmd does...
       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 файл для добавления нового расширения файлов в список:

# Assumes Import_Ext.py is the file that has the code for opening and reading .ext files
FreeCAD.addImportType("Your new File Type (*.ext)","Import_Ext")

Тогда в файле Import_Ext.py:

def open(filename): 
   doc=App.newDocument()
   # here you do all what is needed with filename, read, classify data, create corresponding FreeCAD objects
   doc.recompute()

Экспорт вашего документа в новые типы файлов работает схожим образом, исключая того что вы используете:

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

Добавление линии

Простейшая линия через две точки.

import Part,PartGui 
doc=App.activeDocument() 
# add a line element to the document and set its points 
l=Part.LineSegment()
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()

Добавление многоугольника

Многоугольник это просто набор соединенных отрезков (polyline в AutoCAD). Он необязательно должен быть замкнутым.

import Part,PartGui 
doc=App.activeDocument()
n=list() 
# create a 3D vector, set its coordinates and add it to the list 
v=App.Vector(0,0,0) 
n.append(v) 
v=App.Vector(10,0,0) 
n.append(v) 
#... repeat for all nodes 
# Create a polygon object and set its nodes 
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) # adds the lin object to the group grp
grp.removeObject(lin) # removes the lin object from the group grp

Примечание: Вы также можете добавлять другие группы в группу...

Добавление Полигиональной модели

import Mesh
doc=App.activeDocument()
# create a new empty mesh
m = Mesh.Mesh()
# build up box out of 12 facets
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)
# scale to a edge langth of 100
m.scale(100.0)
# add the mesh to the active document
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") # create a document with a circle feature 
f.Shape = c.toShape() # Assign the circle shape to the shape property 
doc.recompute()

Получение доступа и изменение представления объекта

Каждый объект в FreeCAD документе оссоциируется с визуальным представлением объекта, которое хранит все параметры , определяющие как объект представлен, такие как цвет, длина линий, и.т.д...

gad=Gui.activeDocument()   # access the active document containing all 
                          # view representations of the features in the
                          # corresponding App document 

v=gad.getObject("Cube")    # access the view representation to the Mesh feature 'Cube' 
v.ShapeColor               # prints the color to the console 
v.ShapeColor=(1.0,1.0,1.0) # sets the shape color to white

Наблюдение за поведение мыши в 3D окне через Python

Inventor позваляет добавить оди и более узлов обратного вызова(callback) в дерево сцен просмотрщика. По умолчанию в FreeCAD один узел обратного вызова установлен в кадое окно просмотра(просмотрщик), который позволяет добавить глобальные или статические C++ функции. Соответствуюе Python привязки, некоторые методы которых позволяют использовать эту технику (callback) в Python коде.

App.newDocument()
v=Gui.activeDocument().activeView()
 
#This class logs any mouse button events. As the registered callback function fires twice for 'down' and
#'up' events we need a boolean flag to handle this.
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 перемещений (обычно spaceball)
  • SoKeyboradEvent -- события нажатие и отпускание клавиш клавиатуры
  • SoMouseButtonEvent -- события нажатия и отпускания клавиш мыши
  • SoSpaceballButtonEvent -- события нажатия и отпускания клавиш spaceball

Python функции которые могут быть зарегистрированы в addEventCallback() предлагающем словарь(dictionary). В зависимости от наблюдателя события словарь может содержать различные ключи.

Для всех событий существуют ключи:

  • Type -- Имя типа события т.е. SoMouseEvent, SoLocation2Event, ...
  • Time -- текущие время в виде строки
  • Position -- набор из двух целых чисел как позиция курсорa мыши
  • ShiftDown -- логическая(boolean) переменная, true если Shift нажат, в противном случае false
  • CtrlDown -- логическая(boolean) переменная, true если Ctrl нажат, в противном случае false
  • AltDown -- логическая(boolean) переменная, true если Alt нажат, в противном случае false

Для всех клавишных событий, т.e. для событий клавиатуры, мыши или spaceball

  • State -- Строка 'UP' если кнопка была вверху, 'DOWN' если кнопка была внизу или 'UNKNOWN' во всех остальных случаях

Для событий связанных с клавиатурой:

  • Key -- значение нажатоой клаывиши

Для событий связанных с мышью

  • Button -- Нажаты клавиши, могут быть BUTTON1, ..., BUTTON5 или ANY

Для событий spaceball:

  • Button -- Нажатые клавиши, могут быть BUTTON1, ..., BUTTON7 или ANY

и наконец события движения:

  • Translation -- набор из трех переменных floats
  • Rotation -- кватернион поворота, т.е. набор из четырех переменных floats

Display keys pressed and Events command

This macro displays in the report view the keys pressed and all events command

App.newDocument()
v=Gui.activeDocument().activeView()
class ViewObserver:
   def logPosition(self, info):
       try:
           down = (info["Key"])
           FreeCAD.Console.PrintMessage(str(down)+"\n") # here the character pressed
           FreeCAD.Console.PrintMessage(str(info)+"\n") # list all events command
           FreeCAD.Console.PrintMessage("_______________________________________"+"\n")
       except Exception:
           None
 
o = ViewObserver()
c = v.addEventCallback("SoEvent",o.logPosition)

#v.removeEventCallback("SoEvent",c) # remove ViewObserver

Манипулирование scenegraph в Python

Кроме того можно получить и изменить граф сцены в Python, с помощью модуля 'pivy' -- Python привязки к Coin.

from pivy.coin import *                # load the pivy module
view = Gui.ActiveDocument.ActiveView   # get the active viewer
root = view.getSceneGraph()            # the root is an SoSeparator node
root.addChild(SoCube())
view.fitAll()

Python API для pivy создано используя инструмент SWIG. Так как мы используем в FreeCAD некоторые самостоятельно записанные узлы вы не можете создавать их напрямую через Python. Однако, возможно создать узел в его внутренним именем. Экземпляр типа 'SoFCSelection' может быть создан

type = SoType.fromName("SoFCSelection")
node = type.createInstance()

Добавление и удаление объектов в/из графа сцены

Добавление новых узлов в граф сцены(scenegraph) может сделать таким образом. Всегда заботтесь о добавлении 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)

Saves the sceneGraph with a rotation in a series of 36 files in the X Y Z axis

import math
import time
from FreeCAD import Base
from pivy import coin

size=(1000,1000)
dirname = "C:/Temp/animation/"
steps=36
angle=2*math.pi/steps

matX=Base.Matrix()
matX.rotateX(angle)
stepsX=Base.Placement(matX).Rotation

matY=Base.Matrix()
matY.rotateY(angle)
stepsY=Base.Placement(matY).Rotation

matZ=Base.Matrix()
matZ.rotateZ(angle)
stepsZ=Base.Placement(matZ).Rotation

view=Gui.ActiveDocument.ActiveView
cam=view.getCameraNode()
rotCamera=Base.Rotation(*cam.orientation.getValue().getValue())

# this sets the lookat point to the center of circumsphere of the global bounding box
view.fitAll()

# the camera's position, i.e. the user's eye point
position=Base.Vector(*cam.position.getValue().getValue())
distance=cam.focalDistance.getValue()

# view direction
vec=rotCamera.multVec(Base.Vector(0,0,-1))

# this is the point on the screen the camera looks at
# when rotating the camera we should make this point fix
lookat=position+vec*distance

# around x axis
for i in range(steps):
    rotCamera=stepsX.multiply(rotCamera)
    cam.orientation.setValue(*rotCamera.Q)
    vec=rotCamera.multVec(Base.Vector(0,0,-1))
    pos=lookat-vec*distance
    cam.position.setValue(pos.x,pos.y,pos.z)
    Gui.updateGui()
    time.sleep(0.3)
    view.saveImage(dirname+"x-%d.png" % i,*size)

# around y axis
for i in range(steps):
    rotCamera=stepsY.multiply(rotCamera)
    cam.orientation.setValue(*rotCamera.Q)
    vec=rotCamera.multVec(Base.Vector(0,0,-1))
    pos=lookat-vec*distance
    cam.position.setValue(pos.x,pos.y,pos.z)
    Gui.updateGui()
    time.sleep(0.3)
    view.saveImage(dirname+"y-%d.png" % i,*size)

# around z axis
for i in range(steps):
    rotCamera=stepsZ.multiply(rotCamera)
    cam.orientation.setValue(*rotCamera.Q)
    vec=rotCamera.multVec(Base.Vector(0,0,-1))
    pos=lookat-vec*distance
    cam.position.setValue(pos.x,pos.y,pos.z)
    Gui.updateGui()
    time.sleep(0.3)
    view.saveImage(dirname+"z-%d.png" % i,*size)

Добавление пользовательских виджетов к интерфейсу

Вы можете содать собственные виджеты с помощью Qt designer, превратив их в сценарии на python, с помощью PySide, и загрузив их в FreeCAD.

Python код созданный с помощью Ui python compiler (это инструмент для конвертирования файлов ui. созданных qt-designer в 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())) # sets size of the widget
 
        self.label = QtGui.QLabel(myWidget) # creates a label
        self.label.setGeometry(QtCore.QRect(50,50,200,24)) # sets its size
        self.label.setObjectName("label") # sets its name, so it can be found by name

    def retranslateUi(self, draftToolbar): # built-in QT function that manages translations of widgets
        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() # the active qt window, = the freecad window since we are inside it
# FCmw = FreeCADGui.getMainWindow() # use this line if the 'addDockWidget' error is declared
myNewFreeCADWidget = QtGui.QDockWidget() # create a new dckwidget
myNewFreeCADWidget.ui = myWidget_Ui() # load the Ui script
myNewFreeCADWidget.ui.setupUi(myNewFreeCADWidget) # setup the ui
FCmw.addDockWidget(QtCore.Qt.RightDockWidgetArea,myNewFreeCADWidget) # add the widget to the main window

Adding a Tab to the Combo View

The following code allows you to add a tab to the FreeCAD ComboView, besides the "Project" and "Tasks" tabs. It also uses the uic module to load an ui file directly in that tab.

# create new Tab in ComboView
from PySide import QtGui,QtCore
#from PySide import uic

def getMainWindow():
   "returns the main window"
   # using QtGui.qApp.activeWindow() isn't very reliable because if another
   # widget than the mainwindow is active (e.g. a dialog) the wrong widget is
   # returned
   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)
       elif str(i.objectName()) == "Python Console":
           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)

Enable or disable a window

from PySide import QtGui
mw=FreeCADGui.getMainWindow()
dws=mw.findChildren(QtGui.QDockWidget)

# objectName may be :
# "Report view"
# "Tree view"
# "Property view"
# "Selection view"
# "Combo View"
# "Python console"
# "draftToolbar"

for i in dws:
  if i.objectName() == "Report view":
    dw=i
    break

va=dw.toggleViewAction()
va.setChecked(True)        # True or False
dw.setVisible(True)        # True or False

Opening a custom webpage

import WebGui
WebGui.openBrowser("http://www.example.com")

Getting the HTML contents of an opened webpage

from PySide import QtGui,QtWebKit
a = QtGui.qApp
mw = a.activeWindow()
v = mw.findChild(QtWebKit.QWebFrame)
html = unicode(v.toHtml())
print html

Retrieve and use the coordinates of 3 selected points or objects

# -*- coding: utf-8 -*-
# the line above to put the accentuated in the remarks
# If this line is missing, an error will be returned
# extract and use the coordinates of 3 objects selected
import Part, FreeCAD, math, PartGui, FreeCADGui
from FreeCAD import Base, Console
sel = FreeCADGui.Selection.getSelection() # " sel " contains the items selected
if len(sel)!=3 :
  # If there are no 3 objects selected, an error is displayed in the report view
  # The \r and \n at the end of line mean return and the newline CR + LF.
  Console.PrintError("Select 3 points exactly\r\n")
else :
  points=[]
  for obj in sel:
    points.append(obj.Shape.BoundBox.Center)

  for pt in points:
    # display of the coordinates in the report view
    Console.PrintMessage(str(pt.x)+"\r\n")
    Console.PrintMessage(str(pt.y)+"\r\n")
    Console.PrintMessage(str(pt.z)+"\r\n")

  Console.PrintMessage(str(pt[1]) + "\r\n")

List all objects

# -*- coding: utf-8 -*-
import FreeCAD,Draft
# List all objects of the document
doc = FreeCAD.ActiveDocument
objs = FreeCAD.ActiveDocument.Objects
#App.Console.PrintMessage(str(objs) + "\n")
#App.Console.PrintMessage(str(len(FreeCAD.ActiveDocument.Objects)) + " Objects"  + "\n")

for obj in objs:
    a = obj.Name                                             # list the Name  of the object  (not modifiable)
    b = obj.Label                                            # list the Label of the object  (modifiable)
    try:
        c = obj.LabelText                                    # list the LabeText of the text (modifiable)
        App.Console.PrintMessage(str(a) +" "+ str(b) +" "+ str(c) + "\n") # Displays the Name the Label and the text
    except:
        App.Console.PrintMessage(str(a) +" "+ str(b) + "\n") # Displays the Name and the Label of the object

#doc.removeObject("Box") # Clears the designated object

List the dimensions of an object, given its name

for edge in FreeCAD.ActiveDocument.MyObjectName.Shape.Edges: # replace "MyObjectName" for list
    print edge.Length


Function resident with the mouse click action

Here with SelObserver on a object select

# -*- coding: utf-8 -*-
# causes an action to the mouse click on an object
# This function remains resident (in memory) with the function "addObserver(s)"
# "removeObserver(s) # Uninstalls the resident function
class SelObserver:
    def setPreselection(self,doc,obj,sub):                # Preselection object
        App.Console.PrintMessage(str(sub)+ "\n")          # The part of the object name

    def addSelection(self,doc,obj,sub,pnt):               # Selection object
        App.Console.PrintMessage("addSelection"+ "\n")
        App.Console.PrintMessage(str(doc)+ "\n")          # Name of the document
        App.Console.PrintMessage(str(obj)+ "\n")          # Name of the object
        App.Console.PrintMessage(str(sub)+ "\n")          # The part of the object name
        App.Console.PrintMessage(str(pnt)+ "\n")          # Coordinates of the object
        App.Console.PrintMessage("______"+ "\n")

    def removeSelection(self,doc,obj,sub):                # Delete the selected object
        App.Console.PrintMessage("removeSelection"+ "\n")

    def setSelection(self,doc):                           # Selection in ComboView
        App.Console.PrintMessage("setSelection"+ "\n")

    def clearSelection(self,doc):                         # If click on the screen, clear the selection
        App.Console.PrintMessage("clearSelection"+ "\n")  # If click on another object, clear the previous object
s =SelObserver()
FreeCADGui.Selection.addObserver(s)                       # install the function mode resident
#FreeCADGui.Selection.removeObserver(s)                   # Uninstall the resident function

Other example with ViewObserver on a object select or view

App.newDocument()
v=Gui.activeDocument().activeView()
 
#This class logs any mouse button events. As the registered callback function fires twice for 'down' and
#'up' events we need a boolean flag to handle this.
class ViewObserver:
   def __init__(self, view):
       self.view = view
   
   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")
           pnt = self.view.getPoint(pos)
           FreeCAD.Console.PrintMessage("World coordinates: " + str(pnt) + "\n")
           info = self.view.getObjectInfo(pos)
           FreeCAD.Console.PrintMessage("Object info: " + str(info) + "\n")

o = ViewObserver(v)
c = v.addEventCallback("SoMouseButtonEvent",o.logPosition)

Finding-selecting all elements below cursor

from pivy import coin
import FreeCADGui

def mouse_over_cb( event_callback):
    event = event_callback.getEvent()
    pos = event.getPosition().getValue()
    listObjects = FreeCADGui.ActiveDocument.ActiveView.getObjectsInfo((int(pos[0]),int(pos[1])))
    obj = []
    if listObjects:
        FreeCAD.Console.PrintMessage("\n *** Objects under mouse pointer ***")
        for o in listObjects:
            label = str(o["Object"])
            if not label in obj:
                obj.append(label)
        FreeCAD.Console.PrintMessage("\n"+str(obj))


view = FreeCADGui.ActiveDocument.ActiveView

mouse_over = view.addEventCallbackPivy( coin.SoLocation2Event.getClassTypeId(), mouse_over_cb )

# to remove Callback :
#view.removeEventCallbackPivy( coin.SoLocation2Event.getClassTypeId(), mouse_over)

####
#The easy way is probably to use FreeCAD's selection.
#FreeCADGui.ActiveDocument.ActiveView.getObjectsInfo(mouse_coords)

####
#you get that kind of result :
#'Document': 'Unnamed', 'Object': 'Box', 'Component': 'Face2', 'y': 8.604081153869629, 'x': 21.0, 'z': 8.553047180175781

####
#You can use this data to add your element to FreeCAD's selection :
#FreeCADGui.Selection.addSelection(FreeCAD.ActiveDocument.Box,'Face2',21.0,8.604081153869629,8.553047180175781)

List the components of an object

# -*- coding: utf-8 -*-
# This function list the components of an object
# and extract this object its XYZ coordinates,
# its edges and their lengths center of mass and coordinates
# its faces and their center of mass
# its faces and their surfaces and coordinates
# 8/05/2014

import Draft,Part
def detail():
    sel = FreeCADGui.Selection.getSelection()   # Select an object
    if len(sel) != 0:                           # If there is a selection then
        Vertx=[]
        Edges=[]
        Faces=[]
        compt_V=0
        compt_E=0
        compt_F=0
        pas    =0
        perimetre = 0.0   
        EdgesLong = []

        # Displays the "Name" and the "Label" of the selection
        App.Console.PrintMessage("Selection > " + str(sel[0].Name) + "  " + str(sel[0].Label) +"\n"+"\n")

        for j in enumerate(sel[0].Shape.Edges):                                     # Search the "Edges" and their lengths
            compt_E+=1
            Edges.append("Edge%d" % (j[0]+1))
            EdgesLong.append(str(sel[0].Shape.Edges[compt_E-1].Length))
            perimetre += (sel[0].Shape.Edges[compt_E-1].Length)                     # calculates the perimeter

            # Displays the "Edge" and its length
            App.Console.PrintMessage("Edge"+str(compt_E)+" Length > "+str(sel[0].Shape.Edges[compt_E-1].Length)+"\n")

            # Displays the "Edge" and its center mass
            App.Console.PrintMessage("Edge"+str(compt_E)+" Center > "+str(sel[0].Shape.Edges[compt_E-1].CenterOfMass)+"\n")

            num = sel[0].Shape.Edges[compt_E-1].Vertexes[0]
            Vertx.append("X1: "+str(num.Point.x))
            Vertx.append("Y1: "+str(num.Point.y))
            Vertx.append("Z1: "+str(num.Point.z))
            # Displays the coordinates 1
            App.Console.PrintMessage("X1: "+str(num.Point[0])+" Y1: "+str(num.Point[1])+" Z1: "+str(num.Point[2])+"\n")

            try:
                num = sel[0].Shape.Edges[compt_E-1].Vertexes[1]
                Vertx.append("X2: "+str(num.Point.x))
                Vertx.append("Y2: "+str(num.Point.y))
                Vertx.append("Z2: "+str(num.Point.z))
            except:
                Vertx.append("-")
                Vertx.append("-")
                Vertx.append("-")
            # Displays the coordinates 2
            App.Console.PrintMessage("X2: "+str(num.Point[0])+" Y2: "+str(num.Point[1])+" Z2: "+str(num.Point[2])+"\n")

            App.Console.PrintMessage("\n")
        App.Console.PrintMessage("Perimeter of the form  : "+str(perimetre)+"\n") 

        App.Console.PrintMessage("\n")
        FacesSurf = []
        for j in enumerate(sel[0].Shape.Faces):                                      # Search the "Faces" and their surface
            compt_F+=1
            Faces.append("Face%d" % (j[0]+1))
            FacesSurf.append(str(sel[0].Shape.Faces[compt_F-1].Area))

            # Displays 'Face' and its surface
            App.Console.PrintMessage("Face"+str(compt_F)+" >  Surface "+str(sel[0].Shape.Faces[compt_F-1].Area)+"\n")

            # Displays 'Face' and its CenterOfMass
            App.Console.PrintMessage("Face"+str(compt_F)+" >  Center  "+str(sel[0].Shape.Faces[compt_F-1].CenterOfMass)+"\n")

            # Displays 'Face' and its Coordinates
            FacesCoor = []
            fco = 0
            for f0 in sel[0].Shape.Faces[compt_F-1].Vertexes:                        # Search the Vertexes of the face
                fco += 1
                FacesCoor.append("X"+str(fco)+": "+str(f0.Point.x))
                FacesCoor.append("Y"+str(fco)+": "+str(f0.Point.y))
                FacesCoor.append("Z"+str(fco)+": "+str(f0.Point.z))

            # Displays 'Face' and its Coordinates
            App.Console.PrintMessage("Face"+str(compt_F)+" >  Coordinate"+str(FacesCoor)+"\n")

            # Displays 'Face' and its Volume
            App.Console.PrintMessage("Face"+str(compt_F)+" >  Volume  "+str(sel[0].Shape.Faces[compt_F-1].Volume)+"\n")
            App.Console.PrintMessage("\n")

        # Displays the total surface of the form
        App.Console.PrintMessage("Surface of the form    : "+str(sel[0].Shape.Area)+"\n")

        # Displays the total Volume of the form
        App.Console.PrintMessage("Volume  of the form    : "+str(sel[0].Shape.Volume)+"\n")

detail()

List the PropertiesList

import FreeCADGui
from FreeCAD import Console
o = App.ActiveDocument.ActiveObject
op = o.PropertiesList
for p in op:
    Console.PrintMessage("Property: "+ str(p)+ " Value: " + str(o.getPropertyByName(p))+"\r\n")

Adding one Property "Comment"

import Draft
obj = FreeCADGui.Selection.getSelection()[0]
obj.addProperty("App::PropertyString","GComment","Draft","Font name").GComment = "Comment here"
App.activeDocument().recompute()

Search and data extraction

Examples of research and decoding information on an object.

Each section is independently and is separated by "############" can be copied directly into the Python console, or in a macro or use this macro. The description of the macro in the commentary.

Displaying it in the "View Report" window (View > Views > View report)

# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
 
# Exemples de recherche et de decodage d'informations sur un objet
# Chaque section peut etre copiee directement dans la console Python ou dans une macro ou utilisez la macro tel quel
# Certaines commandes se repetent seul l'approche est differente
# L'affichage se fait dans la Vue rapport : Menu Affichage > Vues > Vue rapport
#
# Examples of research and decoding information on an object
# Each section can be copied directly into the Python console, or in a macro or uses this macro
# Certain commands as repeat alone approach is different
# Displayed on Report view : Menu View > Views > report view
#
# rev:30/08/2014:29/09/2014:17/09/2015
 
from FreeCAD import Base
import DraftVecUtils, Draft, Part
 
mydoc = FreeCAD.activeDocument().Name                                     # Name of active Document
App.Console.PrintMessage("Active docu    : "+(mydoc)+"\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
object_Label = sel[0].Label                                               # Label of the object (modifiable)
App.Console.PrintMessage("object_Label   : "+(object_Label)+"\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
App.Console.PrintMessage("sel            : "+str(sel[0])+"\n\n")          # sel[0] first object selected
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
object_Name  = sel[0].Name                                                # Name of the object (not modifiable)
App.Console.PrintMessage("object_Name    : "+str(object_Name)+"\n\n")
##################################################################################
 
try:
    SubElement = FreeCADGui.Selection.getSelectionEx()                    # sub element name with getSelectionEx()
    element_ = SubElement[0].SubElementNames[0]                           # name of 1 element selected
    App.Console.PrintMessage("elementSelec   : "+str(element_)+"\n\n")            
except:
    App.Console.PrintMessage("Oups"+"\n\n")            
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
App.Console.PrintMessage("sel            : "+str(sel[0])+"\n\n")          # sel[0] first object selected
##################################################################################
 
SubElement = FreeCADGui.Selection.getSelectionEx()                        # sub element name with getSelectionEx()
App.Console.PrintMessage("SubElement     : "+str(SubElement[0])+"\n\n")   # name of sub element
##################################################################################

SubElement = Gui.Selection.getSelectionEx()[0].SubObjects[0].Length       # sub element or element name with getSelectionEx()
App.Console.PrintMessage("SubElement length: "+str(length)+"\n")          # length
##################################################################################

sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
i = 0
for j in enumerate(sel[0].Shape.Edges):                                   # list all Edges
    i += 1
    App.Console.PrintMessage("Edges n : "+str(i)+"\n")
    a = sel[0].Shape.Edges[j[0]].Vertexes[0]
    App.Console.PrintMessage("X1             : "+str(a.Point.x)+"\n")     # coordinate XYZ first point
    App.Console.PrintMessage("Y1             : "+str(a.Point.y)+"\n")
    App.Console.PrintMessage("Z1             : "+str(a.Point.z)+"\n")
    try:
        a = sel[0].Shape.Edges[j[0]].Vertexes[1]
        App.Console.PrintMessage("X2             : "+str(a.Point.x)+"\n") # coordinate XYZ second point
        App.Console.PrintMessage("Y2             : "+str(a.Point.y)+"\n")
        App.Console.PrintMessage("Z2             : "+str(a.Point.z)+"\n")
    except:
        App.Console.PrintMessage("Oups"+"\n")    
App.Console.PrintMessage("\n")    
##################################################################################
 
try:
    SubElement = FreeCADGui.Selection.getSelectionEx()                                        # sub element name with getSelectionEx()
    subElementName = Gui.Selection.getSelectionEx()[0].SubElementNames[0]                     # sub element name with getSelectionEx()
    App.Console.PrintMessage("subElementName : "+str(subElementName)+"\n")
    
    subObjectLength = Gui.Selection.getSelectionEx()[0].SubObjects[0].Length                  # sub element Length
    App.Console.PrintMessage("subObjectLength: "+str(subObjectLength)+"\n\n")
    
    subObjectX1 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[0].Point.x         # sub element coordinate X1
    App.Console.PrintMessage("subObject_X1   : "+str(subObjectX1)+"\n")
    subObjectY1 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[0].Point.y         # sub element coordinate Y1
    App.Console.PrintMessage("subObject_Y1   : "+str(subObjectY1)+"\n")
    subObjectZ1 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[0].Point.z         # sub element coordinate Z1
    App.Console.PrintMessage("subObject_Z1   : "+str(subObjectZ1)+"\n\n")

    try:
        subObjectX2 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[1].Point.x     # sub element coordinate X2
        App.Console.PrintMessage("subObject_X2   : "+str(subObjectX2)+"\n")
        subObjectY2 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[1].Point.y     # sub element coordinate Y2
        App.Console.PrintMessage("subObject_Y2   : "+str(subObjectY2)+"\n")
        subObjectZ2 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[1].Point.z     # sub element coordinate Z2
        App.Console.PrintMessage("subObject_Z2   : "+str(subObjectZ2)+"\n\n")
    except:
        App.Console.PrintMessage("Oups"+"\n\n")            

    subObjectBoundBox = Gui.Selection.getSelectionEx()[0].SubObjects[0].BoundBox              # sub element BoundBox coordinates
    App.Console.PrintMessage("subObjectBBox  : "+str(subObjectBoundBox)+"\n")
    
    subObjectBoundBoxCenter = Gui.Selection.getSelectionEx()[0].SubObjects[0].BoundBox.Center # sub element BoundBoxCenter
    App.Console.PrintMessage("subObjectBBoxCe: "+str(subObjectBoundBoxCenter)+"\n")
    
    surfaceFace = Gui.Selection.getSelectionEx()[0].SubObjects[0].Area                        # Area of the face selected
    App.Console.PrintMessage("surfaceFace    : "+str(surfaceFace)+"\n\n")
except:
    App.Console.PrintMessage("Oups"+"\n\n")            
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
surface = sel[0].Shape.Area                                               # Area object complete
App.Console.PrintMessage("surfaceObjet   : "+str(surface)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
CenterOfMass = sel[0].Shape.CenterOfMass                                  # Center of Mass of the object
App.Console.PrintMessage("CenterOfMass   : "+str(CenterOfMass)+"\n")
App.Console.PrintMessage("CenterOfMassX  : "+str(CenterOfMass[0])+"\n")   # coordinates [0]=X [1]=Y [2]=Z
App.Console.PrintMessage("CenterOfMassY  : "+str(CenterOfMass[1])+"\n")
App.Console.PrintMessage("CenterOfMassZ  : "+str(CenterOfMass[2])+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
for j in enumerate(sel[0].Shape.Faces):                                   # List alles faces of the object
    App.Console.PrintMessage("Face           : "+str("Face%d" % (j[0]+1))+"\n")
App.Console.PrintMessage("\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
volume_ = sel[0].Shape.Volume                                             # Volume of the object
App.Console.PrintMessage("volume_        : "+str(volume_)+"\n\n")
##################################################################################
 
objs = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()

if len(objs) >= 1:
    if hasattr(objs[0], "Shape"):
        s = objs[0].Shape
    elif hasattr(objs[0], "Mesh"):      # upgrade with wmayer thanks #http://forum.freecadweb.org/viewtopic.php?f=13&t=22331
        s = objs[0].Mesh
    elif hasattr(objs[0], "Points"):
        s = objs[0].Points

#sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
#boundBox_= sel[0].Shape.BoundBox                                          # BoundBox of the object
boundBox_= s.BoundBox                                                      # BoundBox of the object
App.Console.PrintMessage("boundBox_      : "+str(boundBox_)+"\n")
 
boundBoxLX  = boundBox_.XLength                                           # Length x boundBox rectangle
boundBoxLY  = boundBox_.YLength                                           # Length y boundBox rectangle
boundBoxLZ  = boundBox_.ZLength                                           # Length z boundBox rectangle
boundBoxDiag= boundBox_.DiagonalLength                                    # Diagonal Length boundBox rectangle

App.Console.PrintMessage("boundBoxLX     : "+str(boundBoxLX)+"\n")
App.Console.PrintMessage("boundBoxLY     : "+str(boundBoxLY)+"\n")
App.Console.PrintMessage("boundBoxLZ     : "+str(boundBoxLZ)+"\n")
App.Console.PrintMessage("boundBoxDiag   : "+str(boundBoxDiag)+"\n\n")

##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
pl = sel[0].Shape.Placement                                               # Placement Vector XYZ and Yaw-Pitch-Roll
App.Console.PrintMessage("Placement      : "+str(pl)+"\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
pl = sel[0].Shape.Placement.Base                                          # Placement Vector XYZ
App.Console.PrintMessage("PlacementBase  : "+str(pl)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
oripl_X = sel[0].Placement.Base[0]                                        # decode Placement X
oripl_Y = sel[0].Placement.Base[1]                                        # decode Placement Y
oripl_Z = sel[0].Placement.Base[2]                                        # decode Placement Z
 
App.Console.PrintMessage("oripl_X        : "+str(oripl_X)+"\n")
App.Console.PrintMessage("oripl_Y        : "+str(oripl_Y)+"\n")
App.Console.PrintMessage("oripl_Z        : "+str(oripl_Z)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
rotation = sel[0].Placement.Rotation                                      # decode Placement Rotation
App.Console.PrintMessage("rotation              : "+str(rotation)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
pl = sel[0].Shape.Placement.Rotation                                      # decode Placement Rotation other method
App.Console.PrintMessage("Placement Rot         : "+str(pl)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
pl = sel[0].Shape.Placement.Rotation.Angle                                # decode Placement Rotation Angle
App.Console.PrintMessage("Placement Rot Angle   : "+str(pl)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
Rot_0 = sel[0].Placement.Rotation.Q[0]                                    # decode Placement Rotation Q
App.Console.PrintMessage("Rot_0         : "+str(Rot_0)+ " rad ,  "+str(180 * Rot_0 / 3.1416)+" deg "+"\n")
 
Rot_1 = sel[0].Placement.Rotation.Q[1]                                    # decode Placement Rotation 1
App.Console.PrintMessage("Rot_1         : "+str(Rot_1)+ " rad ,  "+str(180 * Rot_1 / 3.1416)+" deg "+"\n")
 
Rot_2 = sel[0].Placement.Rotation.Q[2]                                    # decode Placement Rotation 2
App.Console.PrintMessage("Rot_2         : "+str(Rot_2)+ " rad ,  "+str(180 * Rot_2 / 3.1416)+" deg "+"\n")
 
Rot_3 = sel[0].Placement.Rotation.Q[3]                                    # decode Placement Rotation 3
App.Console.PrintMessage("Rot_3         : "+str(Rot_3)+"\n\n")
##################################################################################
 
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
Yaw   = sel[0].Shape.Placement.Rotation.toEuler()[0]                      # decode angle Euler Yaw (Z)
App.Console.PrintMessage("Yaw            : "+str(Yaw)+"\n")
Pitch = sel[0].Shape.Placement.Rotation.toEuler()[1]                      # decode angle Euler Pitch (Y)
App.Console.PrintMessage("Pitch          : "+str(Pitch)+"\n")
Roll  = sel[0].Shape.Placement.Rotation.toEuler()[2]                      # decode angle Euler Roll (X)
App.Console.PrintMessage("Roll           : "+str(Roll)+"\n\n")
##################################################################################

import DraftGeomUtils
sel = FreeCADGui.Selection.getSelection()
vecteur = DraftGeomUtils.findMidpoint(sel[0].Shape.Edges[0])              # find Midpoint
App.Console.PrintMessage(vecteur)
Draft.makePoint(vecteur)
##################################################################################

Manual search of an element with label

# Extract the coordinate X,Y,Z and Angle giving the label 
App.Console.PrintMessage("Base.x       : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Base.x)+"\n")
App.Console.PrintMessage("Base.y       : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Base.y)+"\n")
App.Console.PrintMessage("Base.z       : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Base.z)+"\n")
App.Console.PrintMessage("Base.Angle   : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Rotation.Angle)+"\n\n")
##################################################################################

PS: Usually the angles are given in Radian to convert :

  1. angle in Degrees to Radians :
    • Angle in radian = pi * (angle in degree) / 180
    • Angle in radian = math.radians(angle in degree)
  2. angle in Radians to Degrees :
    • Angle in degree = 180 * (angle in radian) / pi
    • Angle in degree = math.degrees(angle in radian)

Cartesian coordinates

This code displays the Cartesian coordinates of the selected item.

Change the value of "numberOfPoints" if you want a different number of points (precision)

numberOfPoints = 100                                                         # Decomposition number (or precision you can change)
selectedEdge = FreeCADGui.Selection.getSelectionEx()[0].SubObjects[0].copy() # select one element
points  = selectedEdge.discretize(numberOfPoints)                            # discretize the element
i=0
for p in points:                                                             # list and display the coordinates
    i+=1
    print i, " X", p.x, " Y", p.y, " Z", p.z

Other method display on "Int" and "Float"

import Part
from FreeCAD import Base

c=Part.makeCylinder(2,10)        # create the circle
Part.show(c)                     # display the shape

# slice accepts two arguments:
#+ the normal of the cross section plane
#+ the distance from the origin to the cross section plane. Here you have to find a value so that the plane intersects your object
s=c.slice(Base.Vector(0,1,0),0)  # 

# here the result is a single wire
# depending on the source object this can be several wires
s=s[0]

# if you only need the vertexes of the shape you can use
v=[]
for i in s.Vertexes:
    v.append(i.Point)

# but you can also sub-sample the section to have a certain number of points (int) ...
p1=s.discretize(20)
ii=0
for i in p1:
    ii+=1
    print i                                              # Vector()
    print ii, ": X:", i.x, " Y:", i.y, " Z:", i.z        # Vector decode
Draft.makeWire(p1,closed=False,face=False,support=None)  # to see the difference accuracy (20)

## uncomment to use
#import Draft
#Draft.downgrade(App.ActiveDocument.ActiveObject,delete=True)  # first transform the DWire in Wire         "downgrade"
#Draft.downgrade(App.ActiveDocument.ActiveObject,delete=True)  # second split the Wire in single objects   "downgrade"
#
##Draft.upgrade(FreeCADGui.Selection.getSelection(),delete=True) # to attach lines contiguous SELECTED use "upgrade"


# ... or define a sampling distance (float)
p2=s.discretize(0.5)
ii=0
for i in p2:
    ii+=1
    print i                                              # Vector()
    print ii, ": X:", i.x, " Y:", i.y, " Z:", i.z        # Vector decode 
Draft.makeWire(p2,closed=False,face=False,support=None)  # to see the difference accuracy (0.5)

## uncomment to use
#import Draft
#Draft.downgrade(App.ActiveDocument.ActiveObject,delete=True)  # first transform the DWire in Wire         "downgrade"
#Draft.downgrade(App.ActiveDocument.ActiveObject,delete=True)  # second split the Wire in single objects   "downgrade"
#
##Draft.upgrade(FreeCADGui.Selection.getSelection(),delete=True) # to attach lines contiguous SELECTED use "upgrade"

Select all objects in the document

import FreeCAD
for obj in FreeCAD.ActiveDocument.Objects:
    print obj.Name                                # display the object Name
    objName = obj.Name
    obj = App.ActiveDocument.getObject(objName)
    Gui.Selection.addSelection(obj)               # select the object

Selecting a face of an object

# select one face of the object
import FreeCAD, Draft
App=FreeCAD
nameObject = "Box"                             # objet
faceSelect = "Face3"                           # face to selection
loch=App.ActiveDocument.getObject(nameObject)  # objet
Gui.Selection.clearSelection()                 # clear all selection
Gui.Selection.addSelection(loch,faceSelect)    # select the face specified
s = Gui.Selection.getSelectionEx()
#Draft.makeFacebinder(s)                       #

Create one object to the position of the Camera

# create one object of the position to camera with "getCameraOrientation()"
# the object is still facing the screen
import Draft

plan = FreeCADGui.ActiveDocument.ActiveView.getCameraOrientation()
plan = str(plan)
###### extract data
a    = ""
for i in plan:
    if i in ("0123456789e.- "):
        a+=i
a = a.strip(" ")
a = a.split(" ")
####### extract data

#print a
#print a[0]
#print a[1]
#print a[2]
#print a[3]

xP = float(a[0])
yP = float(a[1])
zP = float(a[2])
qP = float(a[3])

pl = FreeCAD.Placement()
pl.Rotation.Q = (xP,yP,zP,qP)         # rotation of object
pl.Base = FreeCAD.Vector(0.0,0.0,0.0) # here coordinates XYZ of Object
rec = Draft.makeRectangle(length=10.0,height=10.0,placement=pl,face=False,support=None) # create rectangle
#rec = Draft.makeCircle(radius=5,placement=pl,face=False,support=None)                   # create circle
print rec.Name

here same code simplified

import Draft
pl = FreeCAD.Placement()
pl.Rotation = FreeCADGui.ActiveDocument.ActiveView.getCameraOrientation()
pl.Base = FreeCAD.Vector(0.0,0.0,0.0)
rec = Draft.makeRectangle(length=10.0,height=10.0,placement=pl,face=False,support=None)

Find normal vector on the surface

This example show how to find normal vector on the surface by find the u,v parameters of one point on the surface and use u,v parameters to find normal vector

def normal(self):
   ss=FreeCADGui.Selection.getSelectionEx()[0].SubObjects[0].copy()#SubObjects[0] is the edge list
   points  = ss.discretize(3.0)#points on the surface edge, 
             #this example just use points on the edge for example. 
             #However point is not necessary on the edge, it can be anywhere on the surface. 
   face=FreeCADGui.Selection.getSelectionEx()[0].SubObjects[1]
   for pp in points:
      pt=FreeCAD.Base.Vector(pp.x,pp.y,pp.z)#a point on the surface edge
      uv=face.Surface.parameter(pt)# find the surface u,v parameter of a point on the surface edge
      u=uv[0]
      v=uv[1]
      normal=face.normalAt(u,v)#use u,v to find normal vector
      print normal
      line=Part.makeLine((pp.x,pp.y,pp.z), (normal.x,normal.y,normal.z))
      Part.show(line)

Read And write one Expression

import Draft
doc = FreeCAD.ActiveDocument

pl=FreeCAD.Placement()
pl.Rotation.Q=(0.0,-0.0,-0.0,1.0)
pl.Base=FreeCAD.Vector(0.0,0.0,0.0)
obj = Draft.makeCircle(radius=1.0,placement=pl,face=False,support=None)    # create circle

print obj.PropertiesList                                                   # properties disponible in the obj

doc.getObject(obj.Name).setExpression('Radius', u'2mm')                    # modify the radius
doc.getObject(obj.Name).setExpression('Placement.Base.x', u'10mm')         # modify the placement 
doc.getObject(obj.Name).setExpression('FirstAngle', u'90')                 # modify the first angle
doc.recompute()

expressions = obj.ExpressionEngine                                         # read the expression list
print expressions

for i in expressions:                                                      # list and separate the data expression
    print i[0]," = ",i[1]


Get the normal vector of a suface from a STL file

def getNormal(cb):
    if cb.getEvent().getState() == coin.SoButtonEvent.UP:
        pp = cb.getPickedPoint()
        if pp:
            vec = pp.getNormal().getValue()
            index = coin.cast(pp.getDetail(), "SoFaceDetail").getFaceIndex()
            print ("Normal: {}, Face index: {}".format(str(vec), index))

from pivy import coin
meth=Gui.ActiveDocument.ActiveView.addEventCallbackPivy(coin.SoMouseButtonEvent.getClassTypeId(), getNormal)

you are done then run for quit:

Gui.ActiveDocument.ActiveView.removeEventCallbackPivy(coin.SoMouseButtonEvent.getClassTypeId(), meth)


На этой странице показано лего можно создать продвинутую фукнкциональность в 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, когда вам требуется использовать функции из другого модуля, вам нужно импортировать его. В нашем случае, нам нужны функции из Модуля Деталей, для создания линии, и из Gui модуля (FreeCADGui), для доступа к 3D виду. Нам также нужно полное содержание библиотеки coin, так мы сможем напрямую использовать все coin объекта такие как SoMouseButtonEvent, и.т.д...

class line:

Здесь мы задаем наш основной класс. Почему мы используем класс а не функцию? Причина в том чтобы нащ инструмент оставался "живым" когда мы ждем что пользователь нажмет на экран. Функция завершится когда её задача будет выполнена, но объект (класс заданый как объект) остается живым пока не будет уничтожен.

"""This class will create a line after the user clicked 2 points on the screen"""

В Python, каждый класс или функция могут обладать строкой описания. Это особенно полезно в FreeCAD, потому что когда вы будете вызывать этот класс через интепритатор, строка описания будет отображатся в виде всплывающей подсказки.

def __init__(self):

Python класс всегда может содержать __init__ функцию, которая выполняется когда класс вызывается для создания объекта. Таким образом, мы положим сюда всё что мы хотим чтобы случилось, когда запустится наш инструмент "линия".

self.view = FreeCADGui.ActiveDocument.ActiveView

В классе, вам обычно нужно добавить self. перед именем переменной, для того чтобы получить легкий доступ к функциям в и вне класса. Здесь мы используем self.view для доступа к управлению активным 3D видом.

self.stack = []

Здесь мы создаем простой список содержащий 3D точки, переданные функцией getpoint.

self.callback = self.view.addEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.getpoint)

Это важная часть: Посколько это фактически coin3D сцена(в смысле окно отображения), FreeCAD использует механизм обратного вызова coin, что позваляет вызывать функцию каждый раз когда на сцене что-то происходит. В нашем случае, мы создаем обратный вызов для события SoMouseButtonEvent , и мы привязываем его getpoint функции. Теперь, каждый раз когда клавиша мыши будет нажата или отпущена, будет выполнятся функция getpoint.

Замети также что существует альтернативна addEventCallbackPivy(), зовется addEventCallback() которая обходится без использование pivy. Но так как pivy это очень эффективный и естественный способ получить доступ к любой части coin сцены, он гораздо лучше для использования так как вы можете!

def getpoint(self,event_cb):

Теперь вы задали getpoint функцию, которая выполняется когда клавиша мыши щелкает по окну 3D вида. Эта функция будет получать аргумент, который мы назовем event_cb. В время обратного вызова мы можем получить доступ к объекту события, который содержит некоторую информацию (информационный режим описан здесь).

if event.getState() == SoMouseButtonEvent.DOWN:

Getpoint функция будет вызыватся когда клавиши мыши будет нажата или отжата. Но мы хотим фиксировать 3D точку только когда нажимаем (в противном случае мы мы можем получить две 3D точки очень близко друг от друга). Так что мы проверяем это.

pos = event.getPosition()

Здесь мы получаем координаты курсора мыши

point = self.view.getPoint(pos[0],pos[1])

Эта функция дает нам FreeCAD вектор (x,y,z) содержащий точку лежащую в фокальной плоскости, т.е. под вашим курсором. Если вы находитесь в режиме камеры, изображается луч идущий из камеры проходящий через курсор мыши, и достигающий фокальной плоскости. Это наша 3D точка. Если мы находимся в режиме ортогонального отображения, луч паралелен направлению вида.

self.stack.append(point)

Мы добавляем новую точку в stack

if len(self.stack) == 2:

Если у вас, уже достаточное количество точек? если да, тогда давайте рисовать линию!

l = Part.Line(self.stack[0],self.stack[1])

Здесь мы используем Line() функцию из Модуля Деталей которая создает линию по двум FreeCAD векторам. Все что мы создаем и модифицируем внутри модуля Деталей, остается в модуле(Part module). Так что, до сих пор, когда мы создавали Line Part. Она не была привязана к какому либо объекту в нашем документе, поэтому ничего и не отображалось на экране.

shape = l.toShape()

FreeCAD документ может принимать только формы(shapes) из модуля Деталей. Формы являются наиболее универсальным типом из модуля Деталей. Таким образом, мы должны преобразовать нашу линию в форму и добавить её в документ.

Part.show(shape)

Модуль деталей обладает очень удобной функцией show() ,которая создает новый объект в документе и привязывает форму к нему. Мы таже могли создать новый объект и привязать к нему форму вручную.

self.view.removeEventCallbackPivy(SoMouseButtonEvent.getClassTypeId(),self.callback)

Теперь, когда мы закончили нашу линию, давайте уберем механизм обратного вызова, который потребляет драгоценные циклы ЦПУ.

Тестирвание & Использование сценария

Теперь, давайте сохраним наш сценарий где нибудь где 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 инструментарий(workbench). Это просто, все что нужно это поместить в файл зовущийся InitGui.py внутрь вашей MyScripts папки. InitGui.py будет содержать инструкции создания нового инструментария, м добавлять наш новый инструмент в него. Кроме того мы должны трансформировать код нашего примера, так чтобы инструмент line() был признан как официальная FreeCAD команда. Начнем с создания InitGui.py файла, и запишем в него следующий код:

class MyWorkbench (Workbench): 
   MenuText = "MyScripts"
   def Initialize(self):
       import exercise
       commandslist = ["line"]
       self.appendToolbar("My Scripts",commandslist)
Gui.addWorkbench(MyWorkbench())

К этому моменту ,