Райан Кларк (Ryan Clark), Chronosapien Interactive

Загрузить PDF[PDF 571KB]

Введение

При проектировании решений, использующих современные технологии мультимедиа (например, управление жестами), наша цель как разработчиков приложений состоит в создании интуитивной, удобной, увлекательной и интересной для пользователя среды взаимодействия. При первом же запуске система навигации должна быть настолько интуитивной, чтобы пользователи могли сразу же начать пользоваться возможностями этого приложения. В наших самых последних экспериментах с технологией Intel^® RealSense™ мы постарались сделать приложение одновременно и удобным, и интересным для пользователей. Вместо того, чтобы использовать Intel RealSense в качестве замены стандартных способов ввода, мы обратили основное внимание на преимущества естественных жестов и уникальных возможностей SDK Intel RealSense. Наше первое приложение Space Betweenиспользует отслеживание лица и рук, а второе включает более редкие возможности SDK, такие как определение эмоций и разделение пользователей. В ходе работы мы получили определенный опыт, который может оказаться полезным для разработчиков, в частности, при проектировании удобных жестов, интерфейсов и меню.

Проектирование ввода для технологии Intel^® RealSense™

Рисунок 1. Приложение Space Between, разработанное для использования технологии Intel^® RealSense™

При создании первого приложения для Intel RealSense мы начали проектирование с анализа возможностей платформы. Вместо изучения возможностей адаптации стиля игры к управлению жестами мы рассматривали уникальные способы взаимодействия, доступные при управлении жестами, и варианты пользовательских интерфейсов на их основе. Поскольку разработка началась с Intel^® Perceptual Computing SDK (предшественник технологии Intel RealSense), мы сосредоточились на двухмерном положении рук и отслеживании раскрытия ладоней в качестве основных методов взаимодействия с пользователем. Используя только эти два простых способа взаимодействия, мы стремились предоставить пользователям самый широкий набор игровых возможностей. Большая часть изменений в игровом процессе связана просто с изменением ориентации руки пользователя, что придает разным жестам разные ощущения, хотя измеряемые значения были одними и теми же.

Основное приложение, созданное с использованием технологии Intel RealSense, называется Space Between. Space Between — это игра, разработанная в Unity*, где игрок исследует морские глубины, управляя различными представителями фауны [рис. 1]. Игра разделена на несколько последовательных мини-игр, в каждой из которых пользователь управляет разными животными и использует разные способы управления. Каждый жест используется так, чтобы имитировать естественное движение соответствующего животного. Так обеспечивается прямое управление. При прямом управлении рука ориентирована в соответствии с положением животного, мгновенно влияет на движение персонажа, поэтому пользователям гораздо проще осваивать управление игрой.

При создании этих мини-игр нужно было начинать с управления с помощью жестов. Мы последовательно прорабатывали каждый жест вплоть до получения приемлемых результатов. Поработав с моделями отслеживания рук, отслеживания лица и распознавания голоса в пакете Intel Perceptual Computing SDK, мы решили, что удобнее всего использовать модуль отслеживания рук. При переходе на Intel RealSense SDK мы обнаружили, что самыми мощными модулями были те, которые осуществляли отслеживание рук, хотя преимуществом всего пакета SDK является изобилие доступных модулей. Во всех мини-играх основным средством управления является отслеживание руки, а отслеживание головы было использовано позже для устранения проблем, связанных с длительными жестами (см. ниже).

Рисунок 2. Волнообразное движение на этапе Sunlight Zone

В первой мини-игре, которая называется Sunlight Zone, игрок управляет морской черепахой при виде сбоку. Проект игры начался с идеи использовать жест, схожий с движением руки, высунутой в окно автомобиля: плавное волнообразное перемещение руки вверх и вниз [рис. 2]. Черепаха повторяет движение руки игрока, набирая скорость с каждым волнообразным движением. Изначально отслеживалось только положение руки по оси Y в поле зрения камеры. После первого пробного этапа мы добились более точного отслеживания за счет измерения угла руки. С помощью этого метода мы сделали так, чтобы положение черепахи в воде соответствовало углу руки пользователя, из-за чего взаимодействие было более естественным. Мы получили значение угла руки из данных об ориентации ладони, предоставляемых модулем отслеживания руки, выделив одну ось [рис. 3].

Рисунок 3. Пример кода с выделением одной оси из данных отслеживания руки

Новые игроки очень быстро осваивали этот жест, но при тестировании игрового процесса оказалось, что менее чем через минуту у игроков уставали руки. На основе этого тестирования мы узнали о «расходе выносливости» [рис. 4] — степени накопления усталости при выполнении жестов поднятыми руками. Проблема состояла в том, что нужно было поднимать локоть перпендикулярно телу, он не поддерживал предплечье, и оказалось, что это один из самых утомительных жестов.

Рисунок 4.Формула расхода выносливости (источник: Consumed Endurance (CE) — измерение усталости руки при выполнении жестов без опоры: http://blog.jhincapie.com/projects/consumed-endurance-ce-measuring-arm-fatigue-during-mid-air-interactions/).

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

Но даже после добавления управления углом руки, чтобы снять усталость, игрокам все равно требовалось отдыхать перед следующей мини-игрой — Midnight Zone. Чтобы дать игрокам отдохнуть, мы добавили мини-игру, в которой не использовались жесты рук. В мини-игре Twilight Zone игрок просто наклоняется в одну из четырех сторон для управления персонажем, имитируя движение персонажа (кита). С точки зрения кода для отслеживания наклона используется отслеживание положения середины головы по оси X и по глубине.

Проектирование интерфейсов для технологии Intel^® RealSense™

Мы быстро поняли, что проектирование приложений, управляемых жестами, — не такой простой процесс. Для демонстрационной версии Space Between нам нужно было добавить простые элементы управления для выбора мини-игр. Для этого мы использовали простые кнопки. Нужен был способ выбора варианта в меню и его принятия. Наш первый интерфейс на основе жестов был прямой заменой управления с помощью мыши [рис. 5].Для выбора мы использовали положение рук, а жест толкания (позднее — большие пальцы вверх) был использован для принятия выбранного варианта. В качестве резерва использовалось голосовое управление. Это решение было создано очень быстро и предполагалось как временное, но мы сразу обнаружили, что работать с меню таким образом было неудобно и трудно. При выполнении жестов зачастую изменялось расположение указателя, из-за чего приходилось делать кнопки с крупными областями выбора. На следующем этапе мы разделили поле зрения камеры на три части и использовали для выбора только положение рук по оси X.

Рисунок 5.Первоначальное меню в демонстрации Space Between для выбора мини-игр

На следующем этапе мы добавили жест прокрутки влево или вправо [рис. 6]для переключения между играми путем вращения кругового меню. Для выбора текущего варианта меню использовался жест толкания (или поднятые большие пальцы). Такой подход оказался лучше с точки зрения наглядности (за счет фактического стимулирования пользователя взаимодействовать с системой), при этом снизилось количество ложных и случайных срабатываний. При проектировании интерфейсов для управления жестами мы обнаружили, что важно повысить чуткость реакции с помощью зрительной и звуковой обратной связи. Это позволило компенсировать отсутствие тактильной реакции.
Рисунок 6.Следующая версия меню выбора мини-игр в демонстрационной версии Space Between

При проектировании интуитивных интерфейсов мы чаще заимствовали принципы, принятые в мобильных интерфейсах, а не в среде ПК. Прокрутка и касание — простые жесты, хорошо известные пользователям, поэтому мы продолжили изучать различные способы их применения. Отметим одну важную особенность жестов в Intel RealSense SDK: при прокрутке каждая рука движется строго в заданном направлении [рис. 7]. Но у жестов махания (не путать с волнообразным движением, которое мы применили в первой мини-игре) направление не задается. Если нужно реализовать поддержку прокрутки любой рукой в любом направлении, следует отслеживать положение руки и определить ее скорость. Преимущество такого подхода состоит в том, что, если движение руки пользователя распознается как прокрутка, можно точно определить время и скорость прокрутки. Это позволяет сообщать инерцию движениям, к чему пользователи уже привыкли на мобильных устройствах.

Рисунок 7.Жесты прокрутки и махания согласно документации Intel

Эти решения превосходны для навигации в меню, но мы обнаружили, что иногда в нашем приложении меню вообще не нужно. При проектировании игры мы часто обращались к примеру Journey. Если вы пока не знаете, что это такое, то Journey — это великолепная приключенческая игра в стиле артхаус, разработанная компанией thatgamecompany. В игре основной упор делается на минимализм, за счет которого выделяются другие элементы игры. Начальный экран представляет собой фоновое изображение пустыни и слова Start: New Journey. Использование меню сведено к крайнему минимуму, а для обучения игроков управлению применяется прозрачная анимация [рис. 8]. При проектировании начального экрана для игры Space Between мы решили вообще отказаться от этапа выбора уровня, а вместо этого сосредоточились на ощущениях пользователей при их первом взаимодействии с игрой. Когда распознается рука пользователя, движения начинают появляться в воздухе перед пользователем, образуя порывы ветра. Пользователь играет с простой сценой перед собой, тем временем порывы ветра раскачивают лодку, начиная создавать атмосферу игры. Пользователю не обязательно выбирать определенный этап. Все мини-игры следуют по очереди.

Рисунок 8.  Снимок экрана игры Journey с минимальным использованием пользовательского интерфейса

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

Рисунок 9.Инструкция по выполнению волнообразного движения в игре Space Between

Поскольку пользователи не знакомы с большинством способов взаимодействия, важно предоставлять обратную связь для действий. Распознавание жестов не всегда работает безупречно, поэтому, если ввод не распознан или распознан неправильно, пользователь должен знать об этом. В нашей демонстрационной версии Space Betweenэто всегда очевидно пользователю: соответствующая информация всегда отображается в верхней части экрана [рис. 10]. При распознавании жестов рук, головы и т. д. появляется соответствующий значок. В полной версии приложения мы решили применить более интегрированный подход. Если система в течение какого-то времени не получает команд от пользователя, соответствующее животное возвращается в состояние по умолчанию. Например, в мини-игре Sunlight Zone, если система не распознает руку пользователя, черепаха поворачивается и плывет прямо, изменяется ее анимация. Мы применили еще один эффект: все персонажи нарисованы так, что под управлением игрока они начинают светиться определенным цветом. Для игр, в которых используется указатель, мы применили плавное появление и исчезание указателя при получении или потере ввода. Также предоставляются соответствующие звуковые подсказки.

Рисунок 10.Наглядная обратная связь при обнаружении рук и головы
в демонстрационной версии игры Space Between

При интеграции сложных меню мы обнаружили, что использовать жесты в качестве основных средств управления было не всегда необходимо. Если приложение это допускает, то использовать мышь и клавиатуру для наиболее сложных элементов — полос прокрутки и ввода данных — всегда гораздо удобнее для пользователей. Жесты удобны для переключателей и кнопок, но управление выбором нужного расположения по нескольким осям может быть затруднено для пользователя. Для решения этой проблемы можно использовать ввод данных путем движения только по одной оси после сжатия или разжатия пальцев, но основную проблему так все равно не решить. Управление с помощью жестов постепенно становится удобнее, но в большинстве случаев пользователи не привыкли к такому способу управления. Если использовать стандартные методы ввода невозможно, то лучше всего просто сделать меню крупнее. При этом также неплохо реализовать поддержку стандартных методов ввода в качестве запасного решения.

Выбор нужного жеста крайне важен при принятии решения о том, какими жестами нужно управлять меню, поскольку показать жесты на экране можно не всегда. Как мы уже говорили, у многих таких действий нет соответствующих им и хорошо известных пользователям жестов. Одним из наиболее заметных примеров является меню приостановки (или настроек). Отображение меню приостановки очень важно в большинстве игр, этот жест должен быть очень быстрым для пользователя и легко и быстро распознаваться приложением. Но из-за таких требований при проектировании возникают существенные затруднения. У жестов других средств ввода (приложения для мыши и клавиатуры, планшеты, мобильные устройства) нет ничего общего. В играх с клавиатурой используется клавиша Escape, на смартфонах обычно применяется прокрутка с левого края экрана к середине (но не всегда). Обычно это действие связано с левым верхним углом экрана, но все равно многие пользователи ассоциируют его с кнопкой закрытия настольного приложения и тянутся к правому верхнему углу. Использование определенных углов экрана или жестов прокрутки не всегда целесообразно из-за прерывистого движения и случайного использования. В приложениях Intel RealSense разработчики Intel рекомендуют использовать знак «V» [рис. 11]для отображения главного меню. Причина выбора именно этого жеста — простота распознавания и низкая вероятность случайного выполнения. Этот жест не является интуитивным и привычным для пользователей, но для образования у пользователей устоявшегося навыка требуется лишь время. Помимо использования этого жеста для меню приостановки мы добавили множество дублирующих систем. При потере отслеживания (когда руки пользователя оказываются вне поля зрения камеры) в течение определенного времени появится меню (с привычным управлением с помощью клавиатуры и мыши).
Рисунок 11.Жест «V» из документации Intel RealSense, рекомендуемый для открытия меню

Несколько модулей с технологией Intel^® RealSense™

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

При работе с модулями SDK, особенно с теми, где используется сигнал с камеры, нужно соблюдать баланс между более высокой кадровой скоростью и более равномерными данными. Если для получения новых данных используется AcquireFrame, то отключение ожидания всех модулей и регулировка максимального времени ожидания позволяют в целом повысить плавность потока данных и кадровую скорость, но возникает вероятность утраты некоторых данных, если время ожидания окажется слишком малым. Медленным компьютерам нужно предоставлять больше времени на обработку данных каждого кадра, а более мощные компьютеры быстрее справятся с такой нагрузкой. В Unity это можно упростить: при более быстрых настройках игры (пониженное качество графики) для обработки данных будет выделяться больше времени, а при более высоком качестве графики — наоборот. Это можно сделать с помощью встроенной в Unity функции QualitySettings [рис. 12].

Рисунок 12.Пример кода с RealSense в потоке Unity, время ожидания зависит от настроек качества

Заключение

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

Дальнейшее развитие и разработка Space Between

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

Помимо функций, связанных с Intel RealSense, существуют и другие компоненты, реализованные в текущей версии Space Between не вполне удачно. При проектировании полной версии игры мы провели исследования жизни обитателей океана, особенно на большой глубине. Нас очень привлекло свечение живых организмов (так называемая биолюминесценция) и зависимость фауны океана от этого эффекта. Нам очень хотелось реализовать это в игре, во-первых, потому что без этого погружение в жизнь в океане было бы неполным, а во-вторых, потому что это просто очень красиво. В текущей версии игры можно видеть некоторые наши попытки интегрировать свечение в среду игры: оно отображается при получении игроком очков, кроме того, морские анемоны испускают свечение на этапе Midnight Zone, а другие обитатели моря — в мини-игре Trenches. Но все это гораздо скромнее наших первоначальных задумок и, конечно, не передает и малой доли природной красоты океана.

Об авторе

Райан Кларк — один из основателей компании Chronosapien Interactive, офис которой находится в Орландо, Флорида, США. Компания Chronosapien Interactive занимается разработкой программного обеспечения, ее специализация — интерактивные виды мультимедиа и современные технологии. В настоящее время компания занимается разработкой демонстрационной версии приложения The Risen, использующего технологию Intel RealSense. Следить за новостями компании можно на сайте chronosapien.reddit.com, а связаться с компанией — по адресу theoracle@chronosapien.com.

Загрузить PDF[PDF 2.06MB]

Рисунок 1. Calligra* Gemini Stage в режиме планшета

Рисунок 2.  Calligra* Gemini Words в режиме планшета

Введение

Выпуск Calligra * Gemini — офисного пакета с открытым исходным кодом с обновленным интерфейсом для трансформеров — ознаменовал новый этап в создании офисных приложений. Представьте, что вы вносите последние изменения в презентацию, а затем передаете клиенту трансформер в планшетном режиме, чтобы можно было управлять просмотром презентации с помощью сенсорного экрана. Или представьте, что можно с легкостью отредактировать документ, когда устройство работает в планшетном режиме.
Все эти сценарии возможны благодаря переключению пользовательского интерфейса в приложении Calligra* Stage для презентаций и в текстовом редакторе Calligra* Words.

Почему Calligra

Компания KO GmBH уже давно выпускает высококачественные приложения и программы с открытым исходным кодом. В прошлом году при содействии корпорации Intel эта компания выпустила первый продукт семейства Gemini — Krita * Gemini. Это приложение с переключаемым пользовательским интерфейсом для рисования и создания иллюстраций;
в 2014 году оно было загружено свыше 100 000 раз. Благодаря переключаемому интерфейсу приложение Krita Gemini особенно удобно для пользователей трансформеров: можно создавать и редактировать изображения на ходу. На рис. 3 показано переключение трансформера из одного режима в другой.

Рисунок 3. Пример трансформера Dell XPS * 12 в процессе трансформации

Компания KO GmBH и специалисты Intel вновь договорились о совместной работе для создания пакета офисных приложений Calligra с переключаемым пользовательским интерфейсом для трансформеров Intel. Поскольку трансформеры получают все более широкое распространение, главный разработчик Дан Лейнир Туртра Йенсен (Dan Leinir Turthra Jensen) и специалист Intel Бьорн Тауберт (Björn Taubert) вместе занялись созданием кода для переключения между режимами в Calligra Gemini. Calligra — это пакет приложений для работы, включая приложения для планирования, создания диаграмм, работы с базами данных, рисования и электронных таблиц в дополнение к обсуждаемым в этой статье приложению для презентаций и текстовому процессору. Эти два приложения были выбраны прежде всего за их удобство на устройствах только с сенсорным управлением: можно использовать одно и то же приложение на настольном ПК, планшете и, что интересует нас в данном случае, на трансформере.

Изменение интерфейса для поддержки сенсорного управления

Разработчики уже получили технический опыт реализации поддержки трансформеров при создании приложения Krita Gemini. Труднее всего было решить, насколько сильно нужно изменять интерфейс в текстовом процессоре и в приложении для презентаций Calligra. Разработчики предложили пользователям и специалистам выработать список элементов управления, которые «должны остаться на экране». Задача состояла в том, чтобы предложить пользователям новый уровень удобства, недоступный до появления устройств-трансформеров. Разработчикам пришлось приспосабливать свои приложения для новых средств управления в дополнение к клавиатуре и мыши, которые используются во всех офисных приложениях с появления первых графических пользовательских интерфейсов. Они добавили поддержку сенсорного управления для повышения удобства в разных режимах использования. Разработчики следили за тем, как пользователи по-разному управляют приложениями Calligra в разных обстоятельствах, и увидели возможность создать приложения, способные адаптироваться к намерениями пользователей.

Решения об устройстве интерфейса приложений принимались на основе таких сценариев. Для удобного доступа пользователей ко всем возможностям приложения разработчики прежде всего обновили интерфейс для настольного режима. Это касается обоих приложений, о которых идет речь в этой статье. Одиночные пользователи, запускавшие Calligra Stage и Words в офисной среде, получили все необходимые и ожидаемые возможности офисного пакета. Но после добавления сенсорного управления (и отказа от традиционных средств ввода) требовалось переделать интерфейс. На первый план вышли такие факторы как мобильность, сотрудничество, потребление информации. Пользователю не предлагается выбирать между созданием или потреблением информации; шире распространены ситуации, когда предоставляются и те, и другие возможности. При появлении трансформеров появилась возможность сочетать наилучшие традиционные средства управления с новыми.

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

На рис. 4 и 5 показан настольный интерфейс приложений Calligra Stage и Words. Разработчики решили вывести на экран множество индикаторов состояния и ярлыков, чтобы пользователи могли создавать новые документы или заниматься редактированием. На рис. 4 обратите внимание на различные возможности навигации по слайдам и на количество кнопок ярлыков для доступа ко множеству возможностей. Каждое приложение с настольным интерфейсом содержит свыше 70 доступных элементов управления и действий.

Рисунок 4. Stage: настольный режим для создания и редактирования

Рисунок 5. Words: настольный режим с возможностями традиционного редактора документов

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

Рисунок 6. Stage: планшетный режим для быстрого редактирования

Рисунок 7. Words: планшетный режим для редактирования и рецензирования

Были реализованы дополнительные сценарии использования, ориентированные на совместную работу пользователей. Для Stage сделали экран воспроизведения презентаций с функциями выделения (как на лекционной доске) и лазерной указки (как на экране проектора). Красный указатель, подобно лазерной указке, дает возможность временно обратить внимание на тот или иной фрагмент. Указатель остается на экране не более одной-двух секунд. С помощью выделения желтым можно привлечь внимание к определенной части экрана до перехода к другому слайду. Ни одно из действий не является фактической правкой документа.
На рис. 8–10 показан экран воспроизведения Stage в планшетном режиме.

Рисунок 8. Stage: планшетный режим для просмотра и воспроизведения

Рисунок 9.Stage: планшетный режим, красный указатель

Рисунок 10. Stage: планшетный режим, выделение желтым

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

Рисунок 11. Words: планшетный режим, наглядные аннотации

Последний элемент, реализованный разработчиками, — создание представления для потребления документов в обоих приложениях. Эти режимы показаны на рис. 12 и 13. Полезная возможность Words — так называемый «не отвлекающий» режим, в котором очень удобно читать документы в естественной книжной ориентации.

Рисунок 12. Words: «не отвлекающий» режим в книжной ориентации

Рисунок 13. Stage: настольный режим для индивидуального потребления информации 

Добавление возможности переключения интерфейса вручную

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

Рисунок 14. Кнопка переключения режима вручную в настольном режиме (слева) и в планшетном режиме (справа). 

Код переключения пользовательского интерфейса показан на рис. 15.

// Snip from Gemini - Perform 2-in1 Mode Transition via Button:

#ifdef Q_OS_WIN
bool MainWindow::winEvent( MSG * message, long * result ) {
     if (message && message->message == WM_SETTINGCHANGE && message->lParam)
     {
         if (wcscmp(TEXT("ConvertibleSlateMode"), (TCHAR *) message->lParam) == 0)
             d->notifySlateModeChange();
         else if (wcscmp(TEXT("SystemDockMode"), (TCHAR *)
message->lParam) == 0)
             d->notifyDockingModeChange();
         *result = 0;
         return true;
     }
     return false;
}
#endif

void MainWindow::Private::notifySlateModeChange()
{
#ifdef Q_OS_WIN
     bool bSlateMode = (GetSystemMetrics(SM_CONVERTIBLESLATEMODE) == 0);

     if (slateMode != bSlateMode)
     {
         slateMode = bSlateMode;
         emit q->slateModeChanged();
         if (forceSketch || (slateMode && !forceDesktop))
         {
             if (!toSketch || (toSketch && toSketch->isEnabled()))
                 q->switchToSketch();
         }
         else
         {
                 q->switchToDesktop();
         }
         //qDebug() << "Slate mode is now"<< slateMode;
     }
#endif
}

void MainWindow::Private::notifyDockingModeChange()
{
#ifdef Q_OS_WIN
     bool bDocked = (GetSystemMetrics(SM_SYSTEMDOCKED) != 0);

     if (docked != bDocked)
     {
         docked = bDocked;
         //qDebug() << "Docking mode is now"<< docked;
     }
#endif
}

Рисунок 15. Фрагмент кода Gemini: переключение между режимами при нажатии кнопки

Заключение

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

Справочные материалы и ссылки

Загрузить Calligra Gemini для Windows * можно с веб-сайта http://userbase.kde.org/Calligra/Download, а получить дополнительные сведения о Calligra Gemini — по адресу http://heap.kogmbh.net/leinir/.

Сведения о разработке для сенсорных устройств и трансформеров
Intel Developer Zone
Трансформеры
Руководство по сенсорному управлению для разработчиков: мобильные устройства
Руководство по разработке ПО для датчиков ультрабуков и планшетов под управлением Windows 8 *
Проектирование для ультрабуков и сенсорных настольных приложений
Как написать приложение, поддерживающее трансформеры
Сенсорный ввод и ввод с помощью пера в Windows * 8
Krita * Gemini * — два режима на трансформере
Изменения пользовательского интерфейса Krita Gemini на трансформерах

Об авторе

Тим Дункан (Tim Duncan) — один из наших инженеров. Друзья называют его «мистер Гаджет». В настоящее время он помогает разработчикам применять в их продуктах новые технологии Intel. Тим обладает многолетним опытом работы в отрасли и знаком со многими ее сторонами — от производства микросхем до интеграции целых систем. Найдите его на сайте Intel® Developer Zone: Tim Duncan (Intel), в Twitter: @IntelTim.

Эта статья взята из блога Ли Дейвиса (Leigh Davies) на IDZ. Здесь описывается работа Ли и его коллеги Филипа Стругара (Filip Strugar) над новым алгоритмом сглаживания, который называется «консервативное морфологическое сглаживание». Ниже приводится содержимое блога и доступный для загрузки проект с исходным кодом.  

В этом примере представлена новая методика сглаживания на этапе постобработки, которая называется «консервативное морфологическое сглаживание». Здесь можно ее загрузить. Этот алгоритм был разработан в корпорации Intel (автор — Филип Стругар) для игры GRID2 компании Codemasters®. Он обладает более высокой производительностью по сравнению с традиционным сглаживанием с многоступенчатой выборкой (MSAA) и более высоким качеством по сравнению с существующими методиками сглаживания на этапе постобработки. В этом примере СМАА сравнивается сразу с несколькими популярными методиками постобработки и с аппаратным сглаживанием MSAA на сцене, отрисовываемой в реальном времени, и на существующем изображении. Эта сцена отрисована с помощью простой методики HDR и содержит простую анимацию, чтобы дать пользователю возможность сравнить обработку различными алгоритмами не только статических частей изображений, но и временных артефактов.

Алгоритм MSAA уже давно используется в компьютерных играх для сглаживания и повышения качества изображения. Обычный алгоритм MSAA работает, запуская пиксельный шейдер один раз для каждого пикселя, но тесты покрытия и наложения запускаются с более высоким разрешением (в 2–8 раз большим), затем результаты объединяются. Такой алгоритм работает значительно быстрее, чем сглаживание с избыточной выборкой, но все равно потребляет значительно больше ресурсов, чем при отсутствии сглаживания. Кроме того, его трудно использовать вместе с определенными методиками. Например, в этом примере используется нестандартный полноэкранный проход, который необходим для исправления цветовых тонов MSAA после HDR MSAA [статья Хумуса (Humus) в ShaderX6] [6].

Альтернативами сглаживанию MSAA являются сглаживание изображений на этапе постобработки (PPAA), реализованное при переносе морфологического сглаживания (MLAA) на ГП [Решетов, 2009] [1], а также дальнейшие разработки, такие как «расширенное субпиксельное морфологическое сглаживание» (SMAA) [2] и «быстрое приблизительное сглаживание» (FXAA) корпорации NVidia [3]. Эти методики сглаживания на этапе постобработки отличаются простотой в реализации (по сравнению с MSAA) и работают в сценариях, когда алгоритм MSAA нельзя использовать (например, при отложенном освещении и в других сценариях сглаживания, основанного не на геометрии), но они не обладают достаточной точностью обработки на субпиксельном уровне и менее стабильны с временной точки зрения. Кроме того, эти методики вызывают заметное размытие текстур и текста, поскольку алгоритмам обнаружения краев трудно различать между преднамеренными разрывами цветов и нежелательным сглаживанием, которое вызвано неточным рендерингом.
В настоящее время два следующих алгоритма сглаживания на этапе постобработки входят в число самых популярных.

1. Алгоритм SMAA создан на основе MLAA, но обладает рядом усовершенствований и новшеств, а также несколькими настройками качества и производительности. В нем применяется усовершенствованное распознавание элементов изображения и адаптация локального контраста, а в более ресурсоемких разновидностях используется временная избыточная выборка, чтобы снизить временную нестабильность и повысить качество. Версия алгоритма SMAA, на которую ссылается этот документ, — последний общедоступный код v2.7.
2. FXAA работает гораздо быстрее. Но в FXAA применяется гораздо более простая методика обнаружения разрыва цветов фигур, что приводит к значительному (и зачастую ненужному) размытию изображений. Кроме того, здесь по умолчанию довольно сильно ограничен размер ядра, поэтому сглаживание фигур с длинными краями выполняется недостаточно, а при повышении размера ядра существенно снижается производительность. В этом документе речь идет об алгоритме FXAA версии 3.8, если не указано иное (в последний момент в дополнение к версии 3.8 в пример была добавлена и новейшая версия 3.11)

В этом примере мы представляем новый алгоритм — консервативное морфологическое сглаживание (CMAA). СМАА удовлетворяет двум условиям, которым в настоящее время не соответствует ни один из существующих алгоритмов.

1. Эффективная работа на ГП малой и средней мощности, например на интегрированных ГП, и при этом реализация высококачественного сглаживания. При разработке этого алгоритма мы установили предел в 3 мс при разрешении 1600 x 900 на процессоре Intel® Core™ 4-го поколения мощностью 15 Вт.
2. Сведение к минимуму инвазивности, чтобы использовать алгоритм вместо 2xMSAA в самых разных областях, включая и наиболее сложные сценарии, такие как текст, повторяющиеся узоры, определенные геометрические формы (линии электропередач, проволочные заборы, листву) и движущиеся изображения.

С точки зрения потребления вычислительной мощности CMAA находится между FXAA и SMAA 1x (нагрузка составляет 0,9–1,2x по сравнению с FXAA 3.11 по умолчанию и 0,45–0,75x по сравнению с SMAA 1x) на ГП Intel HD Graphics 4-го поколения или более поздних. По сравнению с FXAA алгоритм СМАА обеспечивает гораздо более высокое качество изображения за счет правильной обработки линий краев длиной до 64 пикселей. СМАА основан на алгоритме, обрабатывающем только симметричные разрывы цветов, чтобы избежать ненужного размытия (а потому является более консервативным). По сравнению с SMAA 1x этот алгоритм производит сглаживание менее полно, поскольку обрабатывает меньше типов фигур, но также и вызывает меньше размытия, меньше искажений фигур и обладает повышенной временной стабильностью (меньше подвержен влиянию небольших изменений изображений в соседних кадрах).

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

1. Анализ изображения на предмет разрывов цветов (данные затем сохраняются в локальном сжатом «краевом» буфере). Этот метод используется не только в СМАА.
2. Извлечение локальных доминирующих краев с небольшим ядром. (Уникальная разновидность существующих алгоритмов.)
3. Обработка простых фигур.
4. Обработка симметричных фигур с длинными краями. (Уникальная разновидность исходного алгоритма MLAA для обработки фигур.)

Шаг 1. Анализ изображения на предмет разрывов цветов (краев)

Обнаружение краев выполняется путем сравнения соседних цветов с помощью следующих алгоритмов:

• сумма взвешенных по яркости поканальных различий цветов в цветовом пространстве sRGB (по умолчанию);
• значение яркости, вычисленное по входным данным в цветовом пространстве sRGB (более быстрый способ);
• взвешенное Евклидово расстояние [6] (наивысшее качество, самый медленный алгоритм).

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

Шаг 2. Обнаружение локально доминирующих краев (или устранение недоминирующих краев)
Этот шаг выполняет такую же задачу, что и «адаптация локального контраста» в SMAA и «тестирование локального контраста» в FXAA, но с ядром меньшего размера. Для каждого края, обнаруженного на шаге 1, значение разницы цветов, превышающее порог (dEc), сравнивается с аналогичным значением соседних 12 краев (dEn).

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

Шаг 3. Обработка простых фигур

Края, обнаруженные на шаге 1 и уточненные на шаге 2, используются для формирования предположений о форме края перед его растеризацией (виртуальная фигура). Для обработки простых фигур все пиксели анализируются на предмет наличия фигур с 2, 3 и 4 краями, затем применяется передача цвета в соответствии с цветовым покрытием виртуальной фигуры и достижения эффекта локального сглаживания (рис. 4). Такая передача цвета не всегда симметрична, но искажения фигур сводятся к минимальному субпиксельному уровню.

4а. Шаг растеризации пикселей фигуры (как правило, с краями треугольной формы). Критерий для обнаружения показан на рис. 5. Обрабатываются четыре Z-образные ориентации (с разницей в 90°).

4б.Для каждой обнаруженной Z-образной фигуры определяется длина края влево/вправо путем отслеживания горизонтальных (для двух горизонтальных Z-образных фигур) краев с обеих сторон; отслеживание останавливается, если ни с одной из сторон таких краев нет или при обнаружении вертикального края (рис. 6).
4в.Длина края, полученная на предыдущем шаге, используется для восстановления расположения края виртуальной фигуры и для применения передачи цвета (к обеим сторонам Z-образной фигуры) в соответствии с покрытием для каждого пикселя. Этот шаг заменяет все сглаживание для этих же пикселей, сделанное на шаге 3.

За счет естественной симметрии такого подхода лучше сохраняются цвета и фигуры всего изображения, исключаются «пограничные случаи», лучше сохраняются исходные формы, а также повышается временная стабильность.  Изменение одного пикселя (или нескольких пикселей) не приводит к значительному изменению цветов и фигур (по сравнению с SMAA 1X, FXAA 3.8/3.11 и более старыми алгоритмами на базе MLAA).

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

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

Для точного профилирования каждой методики можно использовать кнопку Run benchmark for: … (Запустить измерение для...), чтобы включить автоматическую выборку и сравнение по множеству кадров, а результаты (разница во времени обработки по сравнению с версией без сглаживания) будут показаны в окне сообщения по завершении анализа.

Помимо отображения различных эффектов постобработки в сцене в реальном времени, приложение позволяет загрузить статическое изображение и использовать его в качестве исходного для применения эффектов. В настоящее время для этого поддерживается формат PNG. В папке образцов предоставляется синтетическое изображение (рис. 9). Попытки запуска примера с 2x MSAA и 4x MSAA не дадут результата, поскольку этот алгоритм влияет на источник изображения и не работает при постобработке, но зато к изображению можно применить CMAA, SMAA, FXAA и SAA. Эта возможность позволяет всем разработчикам, выбирающим методики постобработки, загружать изображения из своих приложений и экспериментировать с различными настройками пороговых значений.

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

Справочные материалы
[1] MLAA, А. Решетов (2009). Морфологическое сглаживание. HPG’09: Proceedings of the
Conference on High Performance Graphics, 2009, pages 109–116, New York,NY, USA. ACM
[2] SMAA, Хорхе Хименес (Jorge Jimenez), Хосе Экеваррия (Jose Echevarria), Тьяго Суса
(Tiago Sousa) и Диео Гутиеррес (Diego Gutierrez), 2012,
JIMENEZ2012_SMAA,
SMAA: Enhanced Morphological Antialiasing, форум компьютерной графики (Proc.
EUROGRAPHICS 2012)
[3] NVidia «Быстрое приближенное сглаживание» (FXAA), Тимоти Лотт (Timothy Lottes) (2011),
http://developer.download.nvidia.com/assets/gamedev/files/sdk/11/FXAA_WhitePaper.pdf
[4] Венчеслас Бири (Venceslas Biri), Адриен Эрубель (Adrien Herubel), Стефан Деверли (Stephane Deverly), 2010. Практическое морфологическое
сглаживание на ГП. Обсуждение на ACM SIGGRAPH 2010 (SIGGRAPH '10). ACM, New York, NY,
USA, статья 45, 1 стр. DOI=10.1145/1837026.1837085
http://doi.acm.org/10.1145/1837026.1837085 http://igm.univ-mlv.fr/~biri/mlaa-gpu/MLAAGPU.pdf

[6] «Решение сопоставления оттенков для высококачественного сглаживания HDR в D3D10», ShaderX6

Пять главных преимуществ нового выпуска Intel Media Server Studio 2015 R6

1. Поддержка процессоров пятого поколения (Broadwell). Для ускорения обработки медиа файлов в новом выпуске Media Server Studio реализована поддержка пятого поколения процессоров Intel^® Core и семейства процессоров Intel^® Xeon^® E3-128x v4 со встроенными графическими решениями Intel^® Iris™ Pro. Флагманский процессор для настольных систем Intel^® Core™ i7-5775-C позволяет увеличить скорость обработки медиа файлов на 35 %¹. А благодаря процессорам Xeon кодирование видео выполняется в 1,4 раза быстрее. Это оказывается существенным преимуществом при работе с ресурсоемкими графическими приложениями. 
    
2. БЕСПЛАТНАЯ ВЕРСИЯ Community Edition. Бесплатная версия Community Edition включает в себя все функции Essentials Edition: Media SDK, выполняемые модули, мультимедийные и графические драйверы, OpenCL™ Code Builder и др. Однако на нее не распространяется Intel^® Premier Support (непосредственная поддержка техническими специалистами Intel).
   —    См. подробную информацию на странице с описанием продукта.
   —   Загрузите бесплатную версию.
   —   Ознакомьтесь с документацией, заметками к выпускам и другими руководствами; справочную информацию см. на форуме и в разделе часто задаваемых вопросов.
    

3. HEVC:. Версия Media Server Studio Professional Edition включает в себя программную реализацию HEVC, благодаря которой видео с разрешением 4K можно обрабатывать на процессорах Xeon E5 в режиме реального времени. По сравнению с предыдущими выпусками удалось значительно увеличить производительность (в среднем примерно на 15 %)². Для формата HEVC теперь предусмотрена программная и аппаратная реализация (с ускорением на базе ГП) субдискретизации 4:2:2 с глубиной цвета 10 бит. Удалось значительно улучшить различные методы контроля битрейта, например CBR, VBR и AVBR. Для ПО HEVC и кодировщика с аппаратным ускорением на базе графического процессора поддерживаются средства упреждающего контроля битрейта и оптимизи­рованные методы 1:N LA. Реализация HEVC с аппаратным ускорением стала доступна для большего количества целевых режимов использования. (См. статью об использовании HEVC.)

4. Версия Metrics Monitor и Intel^® VTuneTM Amplifier дляОС Linux*. Чтобы лучше понимать распределение рабочих нагрузок ГП при работе с медиаданными, используйте драйвер уровня ядра ГП в ОС Linux, с помощью которого можно отслеживать необходимые параметры работы. Таким образом вы сможете контролировать состояние определенных аппаратных модулей ГП:
   — механизм рендеринга (исполнительные модули);
   — мультиформатный КОДЕК (MFX);
   — модуль качества видео;
   — модуль для работы с объектами блиттера.
   Реализована поддержка Intel VTune Amplifier для ОС Linux. VTune Amplifier — это отличное средство для настройки параметров и оптимизации работы; с его помощью можно следить за ресурсоемкими областями, потоковой обработкой, блокировками и задержками, OpenCL, полосой пропускания и многим другим.
    
5. Поддержка виртуализации на E5. Используйте программную реализацию Media Server Studio в виртуальной среде E5 — KVM+Xen, Xenserver в ОС Linux. Это позволит вам запустить виртуальный образ операционной системы, работать с несколькими ОС или одновременно выполнять несколько процессов транскодирования.

В этой статье перечислены не все преимущества нового выпуска Media Server Studio 2015 R6; подробную информацию см. в заметках к выпускам.

Заметки к выпуску Media Server Studio Essential/Community Edition для Windows* и Linux

Заметки к выпуску Media Server Studio Professional Edition для Windows и Linux

1 http://www.intel.com/newsroom/kits/computex/2015/pdfs/Computex2015-5th_Gen_Intel_Core-Xeon_FactSheet.pdf
2 https://software.intel.com/ru-ru/intel-media-server-studio/details

Windows Hello — одна из интересных новых функций, объявленных в Windows 10.

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

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

Эта функция работает на основе технологии анализа и безопасного распознавания лиц.

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

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

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

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

С фотографиями или изображениями лица эта функция работать не будет.

Что требуется для работы

В настоящее время существует всего одно автономное устройство, сертифицированное для Windows Hello, — это камера Intel RealSense F200.

Это трехмерная камера, входящая в комплект разработки Intel Realsense SDK. Комплект представляет собой большой набор бесплатных библиотек для поддержки различных функций, таких как распознавание лиц, обнаружение лиц, отслеживание объектов, распознавание жестов, распознавание и синтез речи. Его можно бесплатно загрузить по этой ссылке.

В противном случае потребуется устройство со встроенной камерой RealSense (список таких устройств см. здесь).

Требуется лишь устройство под управлением Windows 10 (или предварительной версии этой ОС).

Как это делается

Подключите камеру к устройству с Windows 10. Система автоматически обнаружит новое устройство.

Для установки нового драйвера и обновления микропрограммы камеры нужно загрузить и установить программу Intel RealSense Depth Camera Manager (DCM) с сайта Intel по этой ссылке.

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

Затем в Windows 10 перейдите в раздел «Настройки/Учетные записи/Параметры входа» и укажите пароль (ПИН-код).

После этого закройте и снова откройте раздел «Настройки/Учетные записи/Параметры входа». Теперь там должна появиться функция Windows Hello.

Щелкните «Настройка», выберите «Начало работы». Система предложит ввести ПИН-код. Введите его, и на экране появится изображение, снятое камерой F200.

После успешного завершения операции появится сообщение о готовности.

Закройте окно и попробуйте сразу же закрыть текущий сеанс.

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

Вот и все!

Удачи!

Корпорация Intel расширяет возможности Photoshop* для использования самых современных алгоритмов сжатия изображений (BCn/DXT) с помощью подключаемого модуля. Цель этого подключаемого модуля — предоставить специалистам по компьютерной графике доступ к более быстрому и высококачественному сжатию в Photoshop*.

Подписаться на бета-версию

До сжатия

После сжатия BC7 (высокое качество)

Преимущества

• Доступ к аппаратным алгоритмам сжатия
• Высокая скорость сжатия
• Предварительный просмотр и удобные возможности для работы
• Совместимость с широко используемыми программами
• Подключаемая архитектура с возможностью добавления новых алгоритмов сжатия

Основные возможности

• Поддержка различных графических форматов для BCn
• Экспорт с расширенным заголовком DirectX10 для sRGB
• Выбор быстрого или высококачественного (более точного) сжатия
• Поддержка альфа-карт, цветовых карт и  карт нормалей
• Поддержка кубических карт со сжатием BCn
• Предварительный просмотр в реальном времени для наглядной оценки качества
• Поддержка пакетов команд и действий Photoshop
• Возможность расширения

Форматы экспорта

Доступные форматы зависят от выбранного типа текстуры. Предоставляется простая контекстная справка. Слева показан список форматов цвета. Полный список приведен ниже.

Требования бета-версии

• Windows (32- или 64-разрядные версии) 7, 8, 10
• Photoshop версии от CS6 до CC2015

Справочные материалы

•  
• Обновление образца сжатия текстур ISPC
• Сжатие BCn
•  

Благодарим за отзывы!

Зарегистрируйтесь на IDZ, чтобы принять участие в обсуждении

Другие сравнения

* Прочие наименования и товарные знаки могут быть собственностью третьих лиц.
© Intel Corporation, 2015. Все права защищены. Intel, эмблема Intel, Intel Atom, Intel Core, Intel Xeon и Intel Iris являются товарными знаками корпорации Intel в США и в других странах.

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

By Edward J. Correia

Корпорация Intel стремится привнести новые возможности во взаимодействие между пользователями и компьютерами, и одним из сторонников новых разработок является Джекоб Пеннок. В 2013 году Пеннок выиграл конкурс Intel Perceptual Computing Challenge, предложив игру Head of the Order*, в которой использовались поистине волшебные возможности управления компьютером без помощи контроллеров. Эта игра была изначально создана с использованием пакета Intel^® Perceptual Computing SDK и камеры Creative Senz3D*. Новая версия игры опирается на новый пакет Intel^® RealSense™ SDKи фронтальную камеру Intel^® RealSense™ 3D. В работе Пеннока и его коллег задействованы новые API и предусмотрены подсказки, которые могут быть использованы другими разработчиками в собственных приложениях.

Получив в свое распоряжение новую версию Intel RealSense SDK и новую компанию Livid Interactive, Пеннок и его команда решили переделать пользовательский интерфейс и расширить возможности игры Head of the Order (рис. 1) путем реализации улучшенного управления с помощью жестов и трехмерного отслеживания рук в Intel RealSense SDK. Эти возможности были недоступны в прежней версии Intel Perceptual Computing SDK.

Рисунок 1. РоликигрыHead of the Order* компании Livid Interactive

Отпакета Perceptual Computing к Intel^® RealSense™ SDK

Улучшенное управление жестами 

Разработчики Head of the Orderбыли особенно заинтересованы новыми возможностями отслеживания рук и пальцев, доступными в Intel RealSense SDK. Эти возможностипозволяют получить трехмерную картину расположения каждого сустава кисти пользователя. Отслеживается 22 точки (см. рис. 2), что позволяет получить весьма высокую точность. В этой игре управление при помощи жестов руки крайне важно. Именно с помощью рук можно создавать и накладывать заклинания, а также соединять несколько заклинаний вместе, чтобы получать более мощные заклинания. 

Рисунок 2.С помощью 22 реперных точек отслеживается точное трехмерное положение руки [Источник изображения]

Трехмерное отслеживание руки

В первоначальном пакете SDK руки пользователя можно было представить только в виде плоских, двухмерных изображений, наложенных на экран (см. рис. 3 [слева]). Для достижения объемного изображения Пенноку пришлось создать систему, которая обрабатывала двухмерные изображения руки низкого разрешения и добавляла их в стек рендеринга игры на различной глубине посредством обработки с помощью собственного кода.

По словам Пеннока, реализация точного отслеживания руки в новом пакете Intel RealSense SDK позволила сделать ощущения от игры гораздо более реалистичными и увлекательными.  Теперь руки отображаются в виде трехмерных моделей (см. рис. 3 и 4 [справа]), которые взаимодействуют с игровым миром.

Рисунок 3.Исходное двухмерное отображение создания заклинаний (слева) и улучшенное трехмерное изображение рук (справа)

Эта функциональность позволяет игрокам полнее погрузиться в атмосферу игры и дает возможность запускать Head of the Orderв шлемах виртуальной реальности. Пакет Intel RealSense SDK значительно повышает точность отслеживания положения всех суставов пальцев, намного лучше определяет глубину, что позволяет точнее и удобнее накладывать заклинания и перемещаться в виртуальном игровом пространстве.

Рисунок 4. Исходное двухмерное отображение создания наложения заклинаний (слева) и улучшенное трехмерное изображение рук (справа)

Переход с Intel Perceptual Computing SDK на Intel RealSense SDK прошел не совсем гладко: потребовалось немало времени, чтобы реализовать всю необходимую функциональность в новом SDK. Тем не менее к моменту выпуска Intel RealSense SDK версии Gold R2 Пенноку и его команде удалось воспроизвести и даже расширить те возможности, которые были достигнуты в предыдущем SDK.

Задачи

В игре Head of the Orderуправление осуществляется полностью при помощи жестов рук; для создания заклинаний нужно рисовать руками в воздухе простые фигуры. Со временем игроки узнают, как сочетать несколько разных жестов воедино, чтобы создавать наиболее мощные заклинания.  При этом научиться управлять игрой при помощи жестов может быть довольно непросто, особенно для игроков, привыкших к традиционным играм, где управление осуществляется с помощью клавиатуры и мыши или игровых контроллеров.  Одна из сложнейших задач для разработчиков состояла в том, чтобы сообщить игрокам, что именно требовалось делать.

Дело в том, что возможности камеры Intel RealSense 3D по распознаванию жестов очень широки. Если игрок делал случайные или нераспознаваемые жесты (например, слишком далеко или слишком близко от камеры), то камера просто не могла «понять», что же пытается сделать игрок. У игроков, привыкших к традиционным интерфейсам, такие ситуации вызывали вполне справедливое раздражение. «Даже если все прекрасно работает, — говорит Пеннок, — игроки могут делать движения, которых камера не ожидает, поэтому может показаться, что система не работает. Исправить такие затруднения на этапе разработки довольно трудно».

Для устранения таких проблем команда Пеннока создала 5-минутное учебное руководство с рассказом и видеороликами, где демонстрируются правильные способы взаимодействия с игрой (см. рис. 5), а игрокам помогают справляться с различными сценариями в игре. Эта идея родилась еще во время первого конкурса, когда тестерам никак не удавалось понять, что для создания заклинания нужно три действия.

Рисунок 5.В учебном материале демонстрируется правильная методика ввода

Наглядные подсказки также важны в игровом процессе, поэтому Пеннок решил отображать такие подсказки и для скорости жестов. Теперь на экране остается след лишь в том случае, если скорость движения руки находится в допустимых пределах. «Во всех прочих случаях, когда мы отслеживаем определенный жест, руки подсвечиваются», — говорит Пеннок. 

Для пользователей, не желающих излишних сложностей, в Head of the Orderпредусмотрены персонажи с очень простыми жестами.

Советы разработчикам

Тестирование

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

И, разумеется, привлечение к тестированию юных пользователей обычно дает лучшие результаты. «Если дети выросли с привычкой пользоваться контроллерами с управлением движениями, такими как Microsoft Kinect*, то они интуитивно и без особых затруднений осваивают и управление при помощи жестов», — говорит Пеннок, добавляя, что проблемы чаще всего возникают у пользователей постарше, например, при демонстрации игр на выставках.

Производительность

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

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

Перспективы

Перечень устройств, на которых можно играть в Head of the Order, постоянно расширяется. Эта игра предназначена только для систем с естественным пользовательским интерфейсом, например с камерой Intel RealSense 3D. Корпорация Intel выпускает различные решения, поддерживающие нужные приложения. В настоящее время в число поддерживаемых устройств входят планшеты, обычные ноутбуки и трансформеры, а также моноблоки, оснащенные технологией Intel RealSense. Более того, многие компании, такие как Acer, Asus, Dell, Fujitsu, Hewlett-Packard, Lenovo и NEC, в настоящее время уже выпускают или объявили о выпуске систем, поддерживающих технологию Intel RealSense.

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

О разработчике

Первоначальная версия игры Head of the Orderбыла создана и представлена на конкурс Intel Perceptual Computing компанией Unicorn Forest Games, принадлежавшей Пенноку. Затем эта компания была объединена с компанией Helios Interactive, в которой Пеннок работал разработчиком. В результате появилась новая компания под названием Livid Interactive, расположенная в Сан-Франциско.

По словам Майкла Шаймана (Michael Schaiman), управляющего партнера компании Helios, его компании поручили разработку принципов работы для Intel^® Experience — своего рода «стендов практической демонстрации», которые обустраивают в 50 крупнейших магазинах сети Best Buy в США. Назначение этих стендов состоит в демонстрации самых современных технологий Intel^®покупателям любого возраста и с любым уровнем технических навыков. Шайману поручили демонстрацию технологии Intel RealSense. «Одна из предложенных нами идей заключалась в создании особой версии игры Head of the Order, в которую могли бы играть посетители, — говорит Шайман. — Им это очень понравилось». Демонстрационная версия Head of the Orderпоступила в магазины в июне 2015 года, а полная версия игры — чуть позже.

Ресурсы Intel

В процессе разработки команда Head of the Orderпроводила ежемесячные телеконференции с инженерами Intel для обсуждения новых технологий. Благодаря этому обмену информацией разработчики Livid всегда были в курсе всех возможностей Intel RealSense SDK, имели доступ к образцам кода и документации и могли оставлять отзывы об уже реализованных решениях.

Дополнительные сведения см. на страницах Intel RealSense SDK
и поддержки. 

Дополнительные сведения о компании Livid Interactive см. здесь.

Введение:

В этой статье мы описываем простую методику оптимизации с использованием Intel^® Cilk™ Plus и компилятора Intel^® C++ на основе результатов анализа производительности, проведенного с помощью Intel^® VTune Amplifier. Intel® System Studio 2015содержит упомянутые компоненты, использованные для этой статьи.

• Intel® VTune Amplifier — интегрированный инструмент для анализа производительности, помогает разработчикам анализировать сложный код и быстро обнаруживать узкие места. 
• Компилятор Intel® C++создает оптимизированный код для архитектур IA-32 и Intel 64. Также предоставляются различные возможности, помогающие разработчикам повышать производительность своих программ.
• Intel® Cilk Plus — это расширение языка C/C++, входящее в состав компилятора Intel® C++, позволяет повышать производительность за счет распараллеливания новых или существующих программ на языке C или C++. 

Стратегия

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

                                                                                                               ↓

 Методика оптимизации производительности, применимая к этому примеру, описана ниже.

1. Запуск простого анализа узких мест или общего анализа для примера проекта в интегрированной среде разработки, например в Visual Studio* 2013.
2. Выявление узких мест и других возможностей для оптимизации.
3. Применение изменений кода к обнаруженным узким местам.
4. Изучение возможностей оптимизации в компиляторе.
5. Распараллеливание кода.

Оптимизация:

< Тестовая среда >

 ОС: Windows 8.1

 Набор инструментов: Intel® System Studio для Windows, обновление 3 

 Среда разработки: Microsoft Visual Studio 2013

< Шаг 1. Интерпретация и анализ данных результатов >

• Запуск общего анализа (если это невозможно, перейдите к простому анализу узких мест) и обнаружение узких мест. Этот пример кода создан как пример для обнаружения узких мест и повышения производительности. Поэтому для работы с ним можно использовать страницу примера the tachyon_amp_ex. После запуска примера в VTune мы получим следующие результаты.

• Видно, что время, затраченное этим приложением, составило 44,834 секунды, и этот базовый уровень производительности мы попытаемся улучшить.
• Кроме того, в этом примере приложения функция initialize_2D_bufferрасходует больше всего времени — 18,945 секунды, поэтому она занимает верхнюю строку в списке ресурсоемких функций. Мы попробуем оптимизировать именно эту функцию, занимающую больше всего времени.

• Гистограмма нагрузки на ЦП, приведенная выше, показывает, что в этом примере не используется параллельная обработка. Поэтому есть возможность использовать многопоточную архитектуру для ускорения обработки ресурсоемких задач.

< Шаг 2. Алгоритмический подход для функции initialize_2D_buffer >

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

• Дважды щелкните имя функции. VTune Amplifier откроет файл с исходным кодом именно на той строке, где на работу этой функции затрачивается больше всего времени. Для функции initialize_2D_buffer эта строка служит для инициализации массива памяти с помощью разрозненных расположений в памяти (находящихся не подряд). У этого примера кода уже есть более быстрая альтернатива циклу for.
• Ниже приведен фактический код функции initialize_2D_buffer. Первый цикл for заполняет целевой массив непоследовательно, тогда как второй цикл for выполняет эту же задачу последовательно. Можно повысить производительность, задействовав второй цикл for.

↓

• После замены цикла for на второй мы отмечаем некоторый прирост производительности. Рассмотрим новые результаты профилирования в VTune.

• По сравнению с прежним результатом общее время выполнения снизилось с 44,834 до 35,742 секунды, то есть примерно в 1,25 раза. Время работы нашей целевой функции сократилось с 18,945 до 11,318 секунды, то есть примерно в 1,67 раза.

< Шаг 3. Возможности оптимизации компилятора >

• Мы зачастую упускаем из вида возможности автоматической оптимизации, доступные в компиляторах. В этом случае мы просто включаем встроенную оптимизацию компилятора Intel C++, указав параметр /O3 при компиляции. Это же можно сделать и с помощью графического пользовательского интерфейса. Чтобы использовать параметр «/O3», нужно сначала установить компилятор Intel C++ в качестве компилятора по умолчанию для данного проекта.

• Одного лишь добавления этого параметра иногда бывает достаточно для существенного повышения производительности. Подробные сведения о параметре оптимизации /O[n] см. здесь. Новые результаты: для выполнения задачи достаточно 24,979 секунды. Прежде нужно было 35,742 секунды, то есть теперь программа работает в 1,43 раза быстрее.

< Шаг 4. Распараллеливание с помощью Cilk Plus >

• Само по себе параллельное программирование — достаточно обширная область. Существует множество способов реализации параллельных вычислений в системе, рассчитанных на работу на многоядерных платформах. На этот раз мы используем Intel Cilk Plus — это довольно простое расширение языка, которое очень неплохо работает.

• При изучении и анализе кода с использованием результатов VTune мы можем найти точку, в которой код многократно вызывает самую ресурсоемкую процедуру. Именно здесь наибольший потенциал для распараллеливания. Обычно это делается так: изучаем дерево вызывающих и вызываемых объектов и возвращаемся к исходному узкому месту до обнаружения фрагмента, пригодного для распараллеливания.
• На этот раз мы просто будем работать с функцией draw_trace в файле find_hotspots.cpp. Достаточно просто добавить cilk_for для распараллеливания нужной нам задачи: вместо одного потока будет задействовано несколько. После этого наглядно видна работа четырех потоков (код тестировался на двухъядерном процессоре с технологией гипертрединга), одновременно рисующих разные линии.

↓

↓

• Теперь для завершения работы достаточно 11,656 секунды, что значительно лучше первоначального времени. Рассмотрим результаты VTune.

• Общее время работы составляет 13,117 секунды, то есть в 1,9 раза быстрее, чем раньше. Мы видим, что многоядерная архитектура эффективно используется.

Заключение:

• Время работы всей программы снизилось с 44,834 до 13,117 секунды, то есть в 3,41 раза.
• Такого уровня оптимизации удалось достичь всего лишь с помощью простого анализа в VTune, добавления параметра компилятора Intel C++ и применения Cilk Plus.
• Компоненты Intel System Studio помогают разработчикам без особых усилий существенно улучшать свои программы.

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

Благодарности

В редактировании этой статьи и приведенного в ней примера кода нам помогли Хавьер Мартинес, Кевин Пател и Теджас Будух.

Введение

До OpenCL™ 2.0 было невозможно проводить операции чтения и записи изображения в рамках одного и того же ядра. Можно было объявлять изображения как CL_MEM_READ_WRITE, но после передачи изображения ядру приходилось выбирать одно из двух: либо __read_only (доступ только для чтения), либо __write_only (доступ только для записи).

input1 = clCreateImage(
oclobjects.context,
CL_MEM_READ_WRITE|CL_MEM_COPY_HOST_PTR,&format,&desc,&input_data1[0],&err );
SAMPLE_CHECK_ERRORS( err );

Фрагмент кода 1. Можно было создать буфер изображения с помощью CL_MEM_READ_WRITE

__kernel void Alpha( __read_write image2d_t inputImage1,
__read_only image2d_t
inputImage2,
uint width,
uint height,
float alpha,
float beta,
int gamma )

Фрагмент кода 2. В OpenCL 2.0 появилась возможность читать и записывать изображения в пределах одного ядра

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

Преимущества изображений, доступных для чтения и записи

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

В OpenCL 1.2 и более ранних версиях изображения могли иметь только квалификаторы __read_only и __write_only. В OpenCL 2.0 появился квалификатор __read_write, выходные данные могут быть скопированы во входной буфер. Это позволяет снизить количество необходимых ресурсов.

В OpenCL 1.2 изображения доступны только для чтения или записи. Для каких-либо изменений изображения необходимо обрабатывать изображение как буфер и работать с этим буфером (см. cl_khr_image2d_from_buffer: https://software.intel.com/ru-ru/articles/using-image2d-from-buffer-extension).

Текущее решение состоит в том, чтобы обрабатывать изображения как буферы и управлять буферами. Для обработки двухмерных изображений как буферов требуется затратить определенное количество ресурсов. При этом также становится невозможно использовать возможности срезания и фильтрации, доступные в read_images. Поэтому желательно использовать изображения с квалификатором read_write.

Обзор примера

В примере два растровых изображения (input1.bmp и input2.bmp) помещаются в буфер. Затем эти изображения накладываются одно на другое на основе значения альфа (это фактор веса в уравнении вычисления пикселей). Значение альфа передается в виде параметра.

Рисунок 1. Альфа = 0,84089642

Входные изображения должны быть 24- или 32-разрядными. На выходе получается 24-разрядное изображение. Входные изображения должны быть одинакового размера. Изображения были в формате ARGB, это учитывалось при их загрузке.

Рисунок 2. Альфа = 0,32453

Формат ARGB преобразуется в RGBA. Изменение значения бета приводит к значительным изменениям выходного изображения.

Использование SDK

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

В образце SDK заданы значения по умолчанию, благодаря чему приложение может работать без какого-либо ввода со стороны пользователя. Пользователи могут использовать собственные входные BMP-файлы. Все файлы должны быть 24- или 32-разрядными. Значение альфа определяет, насколько первое изображение будет накладываться на второе.

calculatedPixel = ((currentPixelImage1 * alpha) + (currentPixeImage2 * beta) + gamma);

Значение бета равно разности между единицей и значением альфа.

float beta = 1 – alpha;

Эти два значения определяют «вес» изображений 1 и 2 в выходном изображении.

Для изменения яркости каждого пикселя можно использовать значение гамма. По умолчанию это значение равно нулю. Пользователь может изменить яркость готового изображения целиком. 

Пример запуска программы

Рисунок 3. Запуск программы на устройстве OpenCL 2.0

Ограничения изображений, доступных для чтения и записи

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

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

В OpenCL 1.2 это пришлось бы делать в два прохода. Одно ядро использовалось бы только для размытия по горизонтали, а другое — для размытия по вертикали. Результат одного размытия будет использоваться в качестве входных данных для следующего (в зависимости от того, какое размытие было первым).

__kernel void GaussianBlurHorizontalPass( __read_only image2d_t inputImage, __write_only image2d_t outputImage, __constant float* mask, int maskSize)
{
    int2 currentPosition = (int2)(get_global_id(0), get_global_id(1));
    float4 currentPixel = (float4)(0,0,0,0);
    float4 calculatedPixel = (float4)(0,0,0,0);
    for(int maskIndex = -maskSize; maskIndex < maskSize+1; ++maskIndex)
    {
        currentPixel = read_imagef(inputImage, imageSampler, currentPosition + (int2)(maskIndex, 0));
        calculatedPixel += currentPixel * mask[maskSize + maskIndex];
    }
    write_imagef(outputImage, currentPosition, calculatedPixel);
}

__kernel void GaussianBlurVerticalPass( __read_only image2d_t inputImage, __write_only image2d_t outputImage, __constant float* mask, int maskSize)
{
    int2 currentPosition = (int2)(get_global_id(0), get_global_id(1));
    float4 currentPixel = (float4)(0,0,0,0);
    float4 calculatedPixel = (float4)(0,0,0,0); 
    for(int maskIndex = -maskSize; maskIndex < maskSize+1; ++maskIndex)
    {
        currentPixel = read_imagef(inputImage, imageSampler, currentPosition + (int2)(0, maskIndex));
        calculatedPixel += currentPixel * mask[maskSize + maskIndex];
    }
    write_imagef(outputImage, currentPosition, calculatedPixel);
}

Фрагмент кода 3. Ядро размытия Гаусса в OpenCL 1.2

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

__kernel void GaussianBlurDualPass( __read_only image2d_t inputImage, __read_write image2d_t tempRW, __write_only image2d_t outputImage, __constant float* mask, int maskSize)
{
    int2 currentPosition = (int2)(get_global_id(0), get_global_id(1));
    float4 currentPixel = (float4)(0,0,0,0);  
    float4 calculatedPixel = (float4)(0,0,0,0)
    currentPixel = read_imagef(inputImage, currentPosition);
    for(int maskIndex = -maskSize; maskIndex < maskSize+1; ++maskIndex)
    {
        currentPixel = read_imagef(inputImage, currentPosition + (int2)(maskIndex, 0));     
        calculatedPixel += currentPixel * mask[maskSize + maskIndex];
    }
    write_imagef(tempRW, currentPosition, calculatedPixel);

    barrier(CLK_GLOBAL_MEM_FENCE);

    for(int maskIndex = -maskSize; maskIndex < maskSize+1; ++maskIndex)
    {
        currentPixel = read_imagef(tempRW, currentPosition + (int2)(0, maskIndex));
        calculatedPixel += currentPixel * mask[maskSize + maskIndex];
    }
    write_imagef(outputImage, currentPosition, calculatedPixel);
}

Фрагмент кода 4. Ядро размытия Гаусса в OpenCL 2.0

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

Справочные материалы

• Спецификация OpenCL 2.0: https://www.khronos.org/registry/cl/specs/opencl-2.0.pdf
• Руководство по программированию OpenCL, A. Munshi и др. (Pearson 2012)
• Программирование OpenCL на примерах, Banfer, Ravishekhar
• Shapiro, L. G. и Stockman, G. C: Computer Vision, стр. 137, 150. Prentice Hall, 2001.
• https://en.wikipedia.org/wiki/Alpha_compositing
• http://mathnathan.com/2010/07/5opencv/

Об авторах

Олудемилад Раджи (Oludemilade Raji) — инженер по графическим драйверам в отделе Visual and Parallel Computing Group корпорации Intel. Он уже в течение 4 лет занимается языком программирования OpenCL и принимал участие в разработке драйверов для Intel HD Graphics, включая разработку OpenCL 2.0.

Роберт Иоффе (Robert Ioffe) работает на должности технического инженера-консультанта в отделе Software and Solutions Group корпорации Intel. Роберт — опытный специалист по программированию OpenCL и оптимизации нагрузки OpenCL на ГП Intel Iris и Intel Iris Pro, он прекрасно знает графическое оборудование Intel. Роберт принимал активное участие в разработке стандартов Khronos, занимался прототипированием самых последних функций и обеспечением их работоспособности в архитектуре Intel. В последнее время Роберт работал над прототипированием возможностей вложенной параллельной обработки (функции enqueue_kernel) OpenCL 2.0, он написал ряд примеров, демонстрирующих эту функциональность, включая алгоритм GPU-Quicksort для OpenCL 2.0. Кроме того, он записал и выпустил два видеоролика по оптимизации ядер OpenCL, сейчас он работает над третьим видеороликом, посвященным возможностям вложенной параллельной обработки.

Загрузить образец кода для потоков камеры R200

Введение

В этом доступном для загрузки коде демонстрируются основы записи и просмотра необработанных потоков камеры R200 на C#/XAML с помощью Intel^® RealSense™ SDK для Windows*. Решение Visual Studio* состоит из четырех простых проектов (размер каждого — не более 200 строк кода).

• ColorStream — отображение цветового потока с камеры RGB.
• DepthStream — отображение потока глубины.
• IRStreams — отображение правого и левого потоков инфракрасной камеры.
• AllStreams — отображение всего перечисленного в одном окне (см. рис. 1).

Рисунок 1. Образец кода для всех потоков

Среда разработки программного обеспечения

Этот образец кода был создан в Windows^® 10 RTM с помощью Microsoft Visual Studio Community 2015. Для этого образца был использован шаблон проекта Visual C# — Windows — Classic Desktop.

Версии SDK и DCM, использованные в этом проекте.

• Intel® RealSense™ SDK                                                       v6.0.21.6598
• Intel® RealSense™ Depth Camera Manager R200              v2.0.3.39488

Описание оборудования

Для данной работы мы использовали комплект Intel^® RealSense™ Developer Kit (R200), в состав которого входит камера, кабель USB3 и магнитное крепление для установки камеры на ноутбуке (рис. 2).

Рисунок 2. Intel^® RealSense™ Developer Kit (R200)

Для образца кода R200 действуют следующие требования к оборудованию:

• Процессор Intel^® Core™ 4-го поколения (или более позднего).
• 150 МБ свободного места на жестком диске.
• ОЗУ 4 ГБ.
• Камера Intel^® RealSense™ (R200).
• Доступный порт USB3 для камеры R200 (или выделенное подключение для встроенной камеры).

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

Описание кода

Решение в Visual Studio состоит из четырех проектов WPF, разработанных на C#. Эти проекты используют явно заданный путь к libpxcclr.cs.dll (управляемой DLL-библиотеке):

C:\Program Files (x86)\Intel\RSSDK\bin\x64

Не забудьте изменить этот путь, если в вашей системе пакет SDK установлен в другую папку.

Так как мы запускаем 64-битную версию DLL, перейдите в меню Project → Properties → Platform target (Проект → Свойства → Целевая платформа)и убедитесь, что там выбрано значение «x64».

Чтобы собрать и запустить определенный проект, щелкните правой кнопкой мыши имя проекта (например, AllStreams) в Solution Explorer (обозревателе решений) и выберите Set as StartUp Project (Назначить запускаемым проектом)в меню.

Все проекты в составе решения CameraStreamsобладают схожей структурой.

• Настройте интерфейсы Session и SenseManager.
• Запустите рабочий поток с именем Update, в котором обрабатывается цикл AcquireFrame — ReleaseFrame.
• В цикле AcquireFrame — ReleaseFrameпроисходят следующие действия.
  • Получение данных изображения.
  • Вызов метода Render для обновления пользовательского интерфейса.
  • Высвобождение ресурсов.
  • Высвобождение кадра.
     
• В методе Renderпроисходят следующие действия.
  • Вызов метода ConvertBitmap для преобразования каждого растрового кадра в тип BitmapImage, который требуется для отображения каждого кадра в элементе управления WPF Image.
  • Обновление пользовательского интерфейса путем делегирования работы диспетчеру, связанному с потоком пользовательского интерфейса.
     
• Метод ShutDownвызывается при каждом возникновении событий Window_Closingили btnExit_Click. В методе ShutDownпроисходят следующие действия.
  • Остановка метода Update.
  • Удаление объектов.

Ознакомьтесь

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

О технологии Intel^® RealSense™

Чтобы приступить к работе и узнать больше об Intel RealSense SDK для Windows, перейдите по адресу https://software.intel.com/ru-ru/intel-realsense-sdk.

Об авторе

Брайан Браун — инженер по разработке программных приложений в подразделении Developer Relations корпорации Intel. 

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

Уведомление

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

Загрузить образец кода для отслеживания лица камерой R200

Введение

В этом примере кода C#/XAML демонстрируются основы работы с алгоритмом отслеживания лиц в Intel^® RealSense™ SDK для Windows* для обнаружения и отслеживания лиц людей в реальном времени с помощью камеры R200. Этот образец кода выполняет следующие действия.

• Отображение цветового потока RGB камеры R200 в элементе управления Image.
• Наложение прямоугольного элемента управления, который отслеживает расположение лица пользователя (в зависимости от того, где находится пользователь в поле зрения камеры).
• Отображение количества лиц, обнаруженных камерой R200.
• Отображение высоты и ширины отслеживаемого лица.
• Отображение двухмерных координат (X и Y) отслеживаемого лица.
• Указание глубины лица, то есть расстояния от камеры R200 до лица.
• Поддержка и отображение отслеживания оповещений, подписка на обработчик событий.

Рисунок 1.Образец кода для отслеживания лиц

Среда разработки программного обеспечения

Этот образец кода был создан в Windows^® 10 RTM с помощью Microsoft Visual Studio* Community 2015. Для этого образца был использован шаблон проекта Visual C# — Windows — Classic Desktop.

Версии SDK и DCM, использованные в этом проекте.

• Intel® RealSense™ SDK                                                       v6.0.21.6598
• Intel® RealSense™ Depth Camera Manager R200              v2.0.3.39488

Описание оборудования

Для этой работы мы использовали комплект Intel^® RealSense™ Developer Kit (R200). Камера была установлена на стандартный штатив с помощью приобретаемого дополнительно магнитного крепления** (рис. 2).

Рисунок 2. Камера, присоединенная к магнитному креплению**

(** Может поставляться не во всех комплектах.)

Для образца кода R200 действуют следующие требования к оборудованию.

• Процессор Intel^® Core™ 4-го поколения (или более позднего).
• 150 МБ свободного места на жестком диске.
• ОЗУ 4 ГБ.
• Камера Intel^® RealSense™ (R200).
• Доступный порт USB3 для камеры R200 (или выделенное подключение для встроенной камеры).

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

Примечания к сборке

1. В этом проекте используется пространство имен System.Drawing.Imaging. Ссылка на него указывается вручную: в новом проекте щелкните правой кнопкой мыши References (Ссылки)в Solution Explorer (обозревателе решений) и выберите Add Reference… (Добавить ссылку…), чтобы открыть окно диспетчера ссылок. Затем выберите Assemblies, Framework (Сборки, платформа)и найдите System.Drawingв списке. Установите флажок и нажмите кнопку ОК.
2. В этом проекте используют явно заданный путь к libpxcclr.cs.dll (управляемой DLL-библиотеке): C:\Program Files (x86)\Intel\RSSDK\bin\x64. Не забудьте изменить этот путь, если в вашей системе пакет SDK установлен в другую папку.
3. Поскольку проект ссылается на 64-разрядную версию DLL-библиотеки, убедитесь, что параметр «x64» указан в разделе Project → Properties → Platform target (Проект → Свойства → Целевая платформа)
4. Проект включает команду события после сборки, чтобы убедиться в копировании неуправляемой DLL-библиотеки (libpxccpp2c.dll) в целевую выходную папку:
   
   if "$(Platform)" == "x86" (copy /y "$(RSSDK_DIR)\bin\win32\libpxccpp2c.dll""$(TargetDir)" ) else ( copy /y "$(RSSDK_DIR)\bin\x64\libpxccpp2c.dll""$(TargetDir)" )

Описание кода

Образец кода имеет следующую структуру.

• Настройте интерфейс Session и SenseManager, а также модуль распознавания лиц.
• Запустите рабочий поток с именем Update, в котором обрабатывается цикл AcquireFrame — ReleaseFrame.
• В цикле AcquireFrame — ReleaseFrameпроисходят следующие действия.
  • Получение данных изображения.
  • Получение данных модуля распознавания лиц.
  • Вызов метода Render для обновления пользовательского интерфейса.
  • Высвобождение ресурсов.
  • Высвобождение кадра.
     
• В методе Renderпроисходят следующие действия.
  • Вызов метода ConvertBitmap для преобразования каждого растрового кадра в тип BitmapImage, который требуется для отображения каждого кадра в элементе управления WPF Image.
  • Обновление пользовательского интерфейса путем делегирования работы диспетчеру, связанному с потоком пользовательского интерфейса.
     
• Метод ShutDownвызывается при каждом возникновении событий Window_Closingили btnExit_Click. В методе ShutDownпроисходят следующие действия.
  • Остановка метода Update.
  • Удаление объектов.

Ознакомьтесь

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

О технологии Intel^® RealSense™

Чтобы приступить к работе и узнать больше об Intel RealSense SDK для Windows, перейдите по адресу https://software.intel.com/ru-ru/intel-realsense-sdk.

Об авторе

Брайан Браун — инженер по разработке программных приложений в подразделении Developer Relations корпорации Intel. 

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

Уведомление

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

Intel® System Studio — мощный интегрированный пакет инструментов, предоставляющий разработчикам мощные системные средства и технологии, ускоряющие создание современных, экономичных, высокопроизводительных и надежных приложений для встраиваемых систем и мобильных устройств.

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

Примеры

Учебные руководства

Загрузить образец кода

В этом проекте демонстрируется определение режима работы ноутбука-трансформера (режим планшета либо режим ноутбука) под управлением Windows* 8(.1), а также новый режим управления с помощью мыши и сенсорного экрана в Windows® 10. Режим управления с помощью мыши и сенсорного экрана аналогичен режиму планшета и ноутбука, но в Windows 10 пользователи получили возможность вручную переключать режим, тогда как в Windows 8 режим переключается только в зависимости от физического состояния устройства. Поэтому пользователи Windows 10 могут использовать расширенный графический пользовательский интерфейс, предназначенный для сенсорного управления, даже на устройствах, не являющихся трансформерами: важно только наличие сенсорного экрана. Эта новая возможность реализована на основе новых API UWP (Universal Windows Platform). Нужно добавить несколько строк кода в приложения, предназначенные для Windows 8, чтобы воспользоваться этой функцией в Windows 10. В этом документе показана доработка приложений Win32 для использования API UWP с помощью WRL (библиотеки шаблонов C++ среды выполнения Windows) в Windows 10. Сведения о включении приложений UWP см. в образце кода Microsoft.

Требования

1. Windows 10
2. Visual Studio* 2015. Новый API отсутствует в Visual Studio 2013

Описание режима управления с помощью мыши и сенсорного экрана в Windows 10

• Настройка вручную
  • Проведите по экрану от правого края экрана к середине, чтобы открыть Центр поддержки (меню чудо-кнопок в Windows 8).
  • Коснитесь кнопки «Режим планшета» для переключения между режимом сенсорного управления и режимом управления с помощью мыши.

• Выбор с помощью оборудования
  • Когда устройство-трансформер обнаруживает изменение физического состояния, оно оповещает об этом ОС.
  • ОС запрашивает подтверждение у пользователя. Если пользователь подтверждает, ОС переключает режим.

• Для проверки перейдите в раздел «Настройки» -> «Система» -> «Планшетный режим» и установите флажок «Всегда запрашивать разрешение перед переключением режима».

• Образец приложения

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

• Windows 10: при ручном или автоматическом переключении будет зарегистрировано событие режима сенсорного управления/управления с помощью мыши и время этого события.
• Windows 8: будут зарегистрированы события изменения физического состояния и их время (режим планшета/режим ноутбука).

В Windows 8 передается сообщение WM_SETTINGCHANGE (lParam == “ConvertibleSlateMode”) при изменении физического состояния, а в Windows 10 передается WM_SETTINGCHANGE (lParam == “UserInteractionMode”) в окно верхнего уровня. При этом также передается и прежнее сообщение. Приложение должно определять версию ОС и выбирать тот или иной код в зависимости от нее. В противном случае приложение в Windows 10 будет дважды реагировать на описанные выше сообщения.

void CMy2in1LogDlg::OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
{
	CDialogEx::OnSettingChange(uFlags, lpszSection);

	// TODO: Add your message handler code here
	if (lpszSection != NULL)
	{
		CString strMsg = CString(lpszSection);

		if (m_dwVersionMajor < 10 && strMsg == _T("ConvertibleSlateMode"))
		{
			CString strTime;
			GetTime(strTime);
			BOOL bSlate = GetSystemMetrics(SM_CONVERTIBLESLATEMODE) == 0;
			CString strMsg = CString(bSlate ? _T("Slate Mode") : _T("Clamshell Mode"));
			m_ctrlEvents.InsertItem(m_iEvent, strTime);
			m_ctrlEvents.SetItemText(m_iEvent, 1, strMsg);
			m_iEvent++;
			return;
		}

		if (m_dwVersionMajor >= 10 && strMsg == _T("UserInteractionMode"))
		{
			CString strTime, strMsg;
			GetTime(strTime);
			int mode;

			if (GetUserInteractionMode(mode) == S_OK)
			{
				if (mode == UserInteractionMode_Mouse)
					strMsg.Format(_T("Mouse Mode"));
				else if (mode == UserInteractionMode_Touch)
					strMsg.Format(_T("Touch Mode"));
				m_ctrlEvents.InsertItem(m_iEvent, strTime);
				m_ctrlEvents.SetItemText(m_iEvent, 1, strMsg);
				m_iEvent++;
			}
		}
	}
}

После того как приложение получает сообщение, оно опрашивает текущее состояние, поскольку сообщение только уведомляет ОС об изменении режима, но не о текущем состоянии. Не существует API Win32, позволяющего опрашивать новое состояние напрямую, но можно использовать WRL для доступа к компонентам Windows RT из приложения Win32, как показано в следующем фрагменте кода.

HRESULT CMy2in1LogDlg::GetUserInteractionMode(int & iMode)
{
	ComPtr<IUIViewSettingsInterop> uiViewSettingsInterop;

	HRESULT hr = GetActivationFactory(
		HStringReference(RuntimeClass_Windows_UI_ViewManagement_UIViewSettings).Get(), &uiViewSettingsInterop);

	if (SUCCEEDED(hr))
	{
		ComPtr<IUIViewSettings> uiViewSettings;
		hr = uiViewSettingsInterop->GetForWindow(this->m_hWnd, IID_PPV_ARGS(&uiViewSettings));
		if (SUCCEEDED(hr))
		{
			UserInteractionMode mode;
			hr = uiViewSettings->get_UserInteractionMode(&mode);
			if (SUCCEEDED(hr))
			{
				switch (mode)
				{
				case UserInteractionMode_Mouse:
					iMode = UserInteractionMode_Mouse;
					break;

				case UserInteractionMode_Touch:
					iMode = UserInteractionMode_Touch;
					break;

				default:

					break;
				}
			}
		}
	}

	return S_OK;
}

Заключение и другие возможности

В этом образце кода показана реализация обнаружения режимов работы трансформера в Windows 8/8.1 и Windows 10 с помощью Win32. В приложениях для Магазина Windows под управлением Windows 8 не было возможности обнаруживать события трансформеров. В Windows 10 поддерживаются API UWP, чтобы универсальные приложения могли использовать функциональность трансформеров. Вместо использования аналогичного API Win32 представлен метод использования API UWP из приложения Win32. Следует отметить, что API UWP не имеют особого уведомления для этого события; они используют события изменения размера окна с последующей проверкой текущего состояния. Если состояние отличается от сохраненного, то предполагается, что оно изменилось. Если использовать сообщения Win32 неудобно (например, в приложениях Java*), можно использовать событие изменения размера окна в Java и вызвать оболочку JNI для подтверждения состояния.

Лицензия
Пример исходного кода распространяется на условиях лицензионного соглашения Intel Sample Source Code License Agreement.

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

Уведомление

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

Предварительные условия:

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

Введение

VTune Amplifier 2016 можно использовать для анализа программ OpenCL™. В этой статье вы узнаете, как использовать это решение, а также как создать простую программу OpenCL под названием HelloOpenCL с помощью Microsoft Visual Studio и Intel OpenCL code builder.

OpenCL — открытый стандарт, предназначенный для реализации параллельного программирования на гетерогенных системах, например в системах с ЦП, GPU, цифровыми сигнальными процессорами, FPGA и другими физическими устройствами. Любые приложения OpenCL обычно содержат две версии кода: для хоста и для устройства (”device kernel” или «ядер»). Хостовые API содержат API двух типов. API платформы предназначены для проверки доступных устройств и их возможностей ,с целью выбора и инициализации устройств OpenCL. API среды выполнения используются для настройки и выполнения ядер на выбранных устройствах. Для разработки кода устройств, выполняемых в среде выполнения OpenCL, можно использовать сборщик кода среды разработки Intel OpenCL. У различных поставщиков оборудования собственная реализация среды выполнения OpenCL. Поэтому обратите внимание на то, чтобы была установлена именно нужная среда.

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

Запустите первую программу OpenCL для ГП — HelloOpenCL

Перед началом разработки программы HelloOpenCL нужно загрузить ряд компонентов. Для сборки кода ядра и проверки совместимости платформы можно загрузить Intel OpenCL code builder, содержащийся в пакете INDE . Во-вторых, на целевое устройство нужно установить реализацию среды выполнения OpenCL. Реализация Intel OpenCL входит в состав графического пакета Intel. Загрузить драйвер можно здесь. Посетите эту страницудля получения инструкций и других вариантов загрузок.

После установки Intel OpenCL code builder можно проверить, какие устройства OpenCL он поддерживает. Эта тестовая целевая система оборудована процессорами Intel® Core™ 4-го поколения (Haswell).

Убедившись, что среда поддерживает нужные устройства OpenCL, как показано на приведенном выше рисунке, можно использовать Microsoft Visual Studio Professional 2013 для создания вашей первой программы OpenCL с помощью установленного шаблона HelloOpenCL, либо использовать непосредственно тот образец кода, который мы включили в данную статью. Этот образец кода запрашивает у устройства GPU выполнение математической операции сложения для двух двухмерных буферов; суммой являются двухмерные выходные буферы. Такой сценарий работы может применяться при использовании типовых фильтров изображений. Вот образец кода HelloOpenCL.
ЗагрузитьDownload

Профилирование HelloOpenCL с помощью VTune Amplifier 2016

После успешной сборки программы HelloOpenCL можно запустить VTune для профилирования приложения в среде разработки Visual Studio. Подробное описание действий по настройке профилирования OpenCL в VTune см. на следующем рисунке.

1. Запустите VTune в среде разработки VS 2013.
2. Выберите типа анализа Advanced Hotspots.
3. Выберите события доступа к памяти графического оборудования.
4. Установите флажок программ OpenCL.

После успешного сбора журналов VTune вы увидите показанный ниже график анализа VTune, перейдя на вкладку Graphics. Сведения о функциях см. в следующих указателях.

1. VTune содержит несколько групповых представлений списка вызовов функций. Для программы openCL для GPU имеется групповое представление Computing Task Purpose/*, позволяющее лучше пояснить эффективность API OpenCL с помощью метрик, поддерживающих OpenCL.
2. Эти аннотации служат для описания кодов API системы OpenCL, выполняющихся на стороне CPU. Они также предоставляют сведения о том, сколько времени CPU занимает одна функция задачи. clBuildProgram интерпретирует код ядра в программу, которую можно запустить в среде выполнения OpenCL. clCreateKernel выбирает одну функцию ядра в предыдущей собранной программе OpenCL, которая может содержать несколько функций ядра. clEnqueueNDRange помещает определенную функцию ядра в очередь команд OpenCL, из которой эта команда принимается и обрабатывается графическим процессором.
3. На этой временной шкале Intel(R) HD Graphics 4… показано, что Add — функция ядра, запланированная в реализации среды выполнения на GPU Intel.
4. Она подсвечивается, когда на оборудовании GPU происходит фактическое действие Add. Между плановым временем выполнения функции ядра и фактическим временем ее выполнения существует промежуток, вызванный определенной подготовкой и переключением контекста.
5. Это новая функция, доступная в последней версии VTune Amplifier 2016. Как показано на следующем рисунке, здесь отображается эффективность передачи данных с помощью статической формы данных и представлены данные о скорости потоков данных в общей схеме архитектуры GPU. Скорость чтения нетипизированной памяти вдвое выше скорости записи, что совпадает с поведением приложения HelloOpenCL.

По этой схеме архитектуры можно также следить за работой буферов, которые в приложении HelloOpenCL выделяются в кэше 3-го уровня. Эффективность использования GPU можно существенно повысить, поскольку большую часть времени GPU бездействует. Другими словами, устройство Intel OpenCL может выполнять более сложные задачи.

Смотрите также

https://software.intel.com/articles/getting-started-with-opencl-code-builder

https://software.intel.com/en-us/articles/opencl-drivers

Введение

Когда я впервые услышал о системе, которая способна определить частоту сердечных сокращений человека бесконтактным способом, я отнёсся к этому скептически, решил, что то, о чём шла речь, находится где-то между откровенным шарлатанством и магией Вуду. Много позже мне понадобилось больше узнать о технологиях, нужных для такого «волшебства». К моему удивлению, подобное оказалось не просто «возможным», но и уже существующим. Более того, это реализовано в последней версии Intel Real Sense SDK.

Я провёл следующий эксперимент. Для начала – нашёл и запустил подходящий пример из SDK и дождался появления результатов измерений. Тут же, в течение 15 секунд, посчитал собственный пульс на сонной артерии и умножил то, что получилось, на четыре. После того, как я сравнил то, что насчитал я, с тем, что выдала программа, я окончательно уверился в том, что это действительно работает! Эксперименты я продолжил: попрыгал немного для того, чтобы слегка «разогнать» сердце и снова позволил компьютеру посчитать пульс. Через несколько секунд он зафиксировал рост частоты сердечных сокращений. Тогда я был в таком восторге от открытия, был так взволнован перспективой использования компьютеров, которые знают, спокоен пользователь или возбуждён, что просто не смог дождаться, когда моё сердцебиение дойдёт до нормальных для меня 76 ударов в минуту и протестировать систему на предмет правильности определения понижения частоты пульса.

Почему это важно

Начав исследовать удивительный мир передовых технологий бесконтактного управления, 3D-сканирования и распознавания движений, вы, через некоторое время, зададитесь вопросом: «А что ещё можно сделать с помощью камеры Intel RealSense?». Когда же вы перейдёте от хорошо изученных, чётко определённых систем, вроде распознавания движений, к более тонким материям, вы попадёте в область, в которой компьютеры способны на невероятные доселе вещи.

Определение частоты пульса, вместе с другими функциями Intel RealSense SDK, это возможности, основанные на работе с едва уловимыми характеристиками физических объектов, которые однажды могут стать такими же важными в повседневной жизни, как мышь и клавиатура сегодня. Например, клавиатура и мышь не очень подходят тому, кто страдает от RSI-синдрома (Repetitive Stain Injury, хроническая травма от повторяющегося напряжения). А если человек расстроен, взволнован, хочет спать, или у него просто плохое настроение, то будь у него самые современные и удобные средства управления ПК, особого толку от них не добиться. Если же компьютеры смогут определять физическое, и, возможно, эмоциональное состояние людей, это позволит машинам помогать пользователям на совершенно новом уровне.

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

Технологические инновации это не всегда нечто в стиле «нажмите эту кнопку и получите результат», не всегда это и улучшения, которые позволяют сделать что-то, что будет быстрее, проще или умнее, чем раньше. Новшества могут быть направлены и на улучшение качества жизни, и на обогащение мировосприятия. И если ваша жизнь станет лучше от того, что компьютер способен «почувствовать», что вам, вероятнее всего, нужно, и предпринять самостоятельные шаги для того, чтобы вам помочь, то это, безусловно – очень хорошо.

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

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

Как это вообще возможно?

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

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

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

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

Еще один подход, который ближе к методике, используемой в Intel RealSense SDK, заключается в обнаружении изменения цвета в потоке видео реального времени. Изменения цвета используются для подсчёта частоты пульса. Частота кадров, необходимая для работы этого метода, не должна быть особенно высокой, камера не должна быть полностью неподвижной. Однако этот метод даёт наилучшие результаты только в идеальных условиях освещения. У данного подхода есть разновидности, каждая из них показывает разные уровни успешного определения частоты пульса. Сейчас мы кратко рассмотрим два варианта «цветовой» методики.

Знаете ли вы, что глаза могут рассказать о том, как быстро бьётся сердце?

Очевидно, что способ определения частоты пульса, основанный на сканировании глаз, лучше работает, если пользователь не носит очки. Кроме того, чем ближе глаза к камере, тем выше шанс определить небольшие изменения в глазных кровяных сосудах в ходе процедуры подсчёта частоты пульса. В отличие от сосудов, расположенных под кожей, при наблюдении за которыми проявляется подповерхностное рассеяние и другие помехи, глаза – это довольно таки прозрачное «окно», открывающее вид на сосудистую систему головы. При реализации этого метода, однако, придётся справиться с некоторыми трудностями. Например – захватывать только те пиксели получаемого изображения, которые относятся к глазам. Нужно это для того, чтобы работать только с изображением глаз, а не с изображением окружающей их кожи. Кроме того, нужно потрудиться над определением морганий, надо отслеживать положение зрачка для того, чтобы в образцы, на основе которых определяется пульс, не попало ничего постороннего. И, наконец, нужно, чтобы съёмка производилась достаточно долго для того, чтобы на её основе выявить фоновые шумы, которые нужно устранить перед тем, как начать плотную работу с оставшимися цветовыми пикселями, на основе анализа которых и определяется пульс.

Длительность процедуры может меняться в зависимости от времени, которое понадобится для того, чтобы получить подходящий материал для анализа. Кроме того, если при съёмке в кадрах окажется слишком много шума, их придётся отбросить и повторить процедуру. Но, даже если выполнять съёмку на умеренных 30 кадрах в секунду, для того, чтобы зафиксировать одно биение пульса, понадобится 20-30 кадров (это, если предположить, что частота сердцебиения испытуемого составляет 30 – 90 ударов в минуту).

Если вы столкнётесь с ситуацией, когда цветовой информации, полученной при съёмке глаз, недостаточно, а такое может произойти, например, если испытуемый находится довольно далеко от компьютера, или носит очки, или попросту медитирует, вам понадобится другой подход для подсчёта пульса. Один из вариантов анализа изменения цвета тканей тела заключается в использовании потока в инфракрасной части спектра (IR, InfraRed). Такой поток можно получить с камеры Intel RealSense. В отличие от потоков, предоставляющих сведения о цвете и глубине пространства, инфракрасный поток может поставлять данные для последующей обработки с частотой около 300 кадров в секунду. Это довольно высокая скорость. Как было отмечено выше, нам, для подсчёта пульса, достаточно получить хорошие материалы с частотой около 30 кадров в секунду. При обработке инфракрасного изображения, которое можно получить с камеры, используется особый подход.

Обратите внимание на то, что вены на запястье хорошо видны на инфракрасном видеопотоке.

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

Один из побочных эффектов, возникающих при захвате инфракрасных лучей, отражающихся от тела человека, заключается в том, что на полученном изображении можно обнаружить сосуды, расположенные близко к поверхности кожи. В ИК-диапазоне можно разглядеть и следы машинного масла на футболке, которая при обычном освещении выглядит идеально. Учитывая, что поток крови очень точно отражает то, что мы хотим измерить, вы можете решить, что рассматриваемый метод идеально подходит для определения частоты пульса. Если вы немного углубитесь в этот вопрос, то обнаружите, что ИК-сканирование человеческого тела действительно используется в медицинских исследованиях для изучения циркуляции крови по кровеносной системе. Однако делается это под строгим врачебным контролем. Минус использования ИК-лучей заключается в том, что мы, фактически, ограничиваем объём информации, получаемый с камеры, не используя данные о цвете из видимого спектра, которые можно извлечь из обычного цветного видеоканала.

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

Как Intel RealSense определяет частоту пульса

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

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

Для начала нам нужно создать PXC-сессию и указатель SenseManager. Так же нам понадобится указатель faceModule, так как мы будем пользоваться системой Face для того, чтобы подсчитывать частоту пульса. Полная версия этого кода лучше всего представлена в образце Face Tracking, его вы можете найти и скомпилировать. В нём, помимо кода, который показан здесь, есть и поддержка дополнительных возможностей – таких, как определение позы.

PXCSession* session = PXCSession_Create();
PXCSenseManager* senseManager = session->CreateSenseManager();
senseManager->EnableFace();
PXCFaceModule* faceModule = senseManager->QueryFace();

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

PXCFaceConfiguration* config=faceModule->CreateActiveConfiguration();
config->QueryPulse()->Enable();
config->ApplyChanges();

Объект ActiveConfiguration включает в себя все настройки, необходимые для работы системы Face, однако одна строка кода, QueryPulse()->Enable(), имеет непосредственное отношение к подсчёту пульса. Она включает нужную нам часть системы и поддерживает её работу.

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

PXCFaceData* faceOutput = faceModule->CreateOutput();
const int numFaces = faceOutput->QueryNumberOfDetectedFaces();
for (int i = 0; i < numFaces; ++i)
{
	PXCFaceData::Face* trackedFace = faceOutput->QueryFaceByIndex(i);
	const PXCFaceData::PulseData* pulse = trackedFace->QueryPulse();
	if (pulse != NULL)
	{
		pxcF32 hr = pulse->QueryHeartRate();
	}
}

Разбирая этот код, вы можете не обращать особого внимания на всё, кроме вызова trackedFace->QueryPulse(), который запрашивает у системы частоту пульса, полученную на основе ранее собранных данных. Если данные о пульсе имеются, применяется вызов pulse->QueryHeartRate() для того, чтобы извлечь нужную нам информацию и возвратить её в формате частоты сердечных сокращений в минуту.

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

Для того чтобы измерить собственный пульс, запустите пример Face Tracking, который поставляется вместе с RealSense SDK. В правой части окна программы оставьте выбранными пункты Detection (Обнаружение) и Pulse (Пульс), нажмите на кнопку Start (Пуск) и секунд 10 спокойно посидите.

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

Секреты и советы

Это стоит попробовать:
 

• Для того, чтобы получить наилучшие результаты, причём – это касается любой работы с видеопотоками, а не только определения пульса, пользуйтесь камерой в хороших условиях освещённости (не при солнечном свете) и старайтесь оставаться неподвижным в фазе захвата изображения до тех пор, пока не получите точные результаты.
   
• Так как в текущей версии SDK имеется лишь одна функция для определения частоты пульса, перед вами – широко распахнутая дверь для новаторов, которые, на основе необработанных данных, смогут получить более точные сведения о частоте сердцебиения или ускорить этот процесс. Сейчас для определения частоты пульса требуется около 10 секунд. Сможете написать программу, которая делает это быстрее?
   
• Если вы собираетесь определять частоту сердечных сокращений на улице и хотите написать собственный алгоритм анализа данных, рекомендуется использовать только цветовой видеопоток для определения изменения цвета кожи.

Этого лучше не делать:
 

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

Итоги

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

Если говорить лично обо мне, то я веду жизнь перегруженного работой программиста старой школы, перемалывающего тонны кода. Сегодня собственное здоровье и экология моего рабочего места значат для меня гораздо больше, чем в юности. Поэтому я с радостью приму любую помощь. И если эта помощь обретёт вид компьютера, который будет одолевать меня сообщениями вроде: «просыпайся; выпей кофе; подними голову; не забудь; открой окно; сделай паузу; поешь чего-нибудь; прогуляйся на свежем воздухе; поиграй в какую-нибудь игру; сходи к доктору, похоже, у тебя пульс пропал; послушай Моцарта; отправляйся спать», в особенности, если эти напоминания будут делаться приятным компьютерным голосом, тогда – да будет так.

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

Пример кода

Управление дронами с помощью приложений для распознавания речи на основе Intel® RealSense™ SDK

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

Разработчики могут создавать приложения для управления дронами. Дрон в конечном итоге является обычным программируемым устройством, поэтому к нему можно подключаться и отдавать команды для выполнения нужных действий с помощью обычных приложений для ПК и смартфонов. Для этой статьи я выбрал один из дронов с самыми мощными возможностями программирования — AR.Drone* 2.0 компании Parrot.

Мы узнаем, как взаимодействовать с таким дроном и управлять им с помощью библиотеки, написанной на C#. Опираясь на эту основу, мы добавим речевые команды для управления дроном с помощью Intel® RealSense™ SDK.

PARROT AR.DRONE 2.0

Модель AR.Drone 2.0 компании Parrot — один из наиболее интересных дронов, предлагаемых на рынке для энтузиастов. Этот дрон обладает множеством функций и включает встроенную систему помощи с интерфейсами стабилизации и калибровки. Дрон оснащен защитным каркасом из прочного пенополистирола, предохраняющим лопасти винтов и движущиеся части в случае падения или столкновения с неподвижными препятствиями.

AR.Drone* 2.0 компании Parrot

Оборудование дрона обеспечивает его подключение по собственной сети Wi-Fi* к внешним устройствам (смартфонам, планшетам, ПК). Протокол связи основан на АТ-подобных сообщениях (подобные команды несколько лет назад использовались для программирования модемов для связи по телефонной сети).

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

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

Программное управление дроном

У дрона есть собственная сеть Wi-Fi, поэтому подключимся к ней для передачи команд управления. Всю нужную информацию мы нашли в руководстве для разработчиков AR.Drone 2.0. Например, в руководстве сказано, что нужно отправлять команды по протоколу UDP на IP-адрес 192.168.1.1, порт 5556. Это простые строки в формате AT:

• AT * REF — управление взлетом и посадкой;

• AT * PCMD — движение дрона (направление, скорость, высота).

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

Сначала нужно подключиться к устройству.

public static async Task ConnectAsync(string hostName = HOST_NAME, string port = REMOTE_PORT)
        {
             // Set up the UDP connection.
             var droneIP = new HostName(hostName);

             udpSocket = new DatagramSocket();
             await udpSocket.BindServiceNameAsync(port);
             await udpSocket.ConnectAsync(droneIP, port);
             udpWriter = new DataWriter(udpSocket.OutputStream);

             udpWriter.WriteByte(1);
             await udpWriter.StoreAsync();

             var loop = Task.Run(() => DroneLoop());
        }

Как уже было сказано ранее, нужно использовать протокол UDP, следовательно, нужен объект DatagramSocket. После подключения с помощью метода ConnectAsyncмы создаем DataWriterв выходном потоке для отправки команд. И наконец, мы отправляем первый байт по Wi-Fi. Он служит только для инициализации системы и будет отброшен дроном.

Проверим команду, отправленную дрону.

        private static async Task DroneLoop()
        {
            while (true)
            {

                var commandToSend = DroneState.GetNextCommand(sequenceNumber);
                await SendCommandAsync(commandToSend);

                sequenceNumber++;
                await Task.Delay(30);
            }
        }

Тег DroneState.GetNextCommandформатирует строковую АТ-команду, которую нужно отправить устройству. Для этого нужен порядковый номер: дрон ожидает, что каждая команда сопровождается порядковым номером, и игнорирует все команды, номера которых меньше или равны номерам уже полученных команд.

После этого мы используем WriteStringдля отправки в поток команд через StreamSocket, при этом StoreAsyncзаписывает команды в буфер и отправляет их. И наконец, мы увеличиваем порядковый номер и используем параметр Task Delay, чтобы ввести задержку в 30 миллисекунд перед следующей итерацией.

Класс DroneStateопределяет, какую команду отправить.

    public static class DroneState
    {
       public static double StrafeX { get; set; }
       public static double StrafeY { get; set; }
       public static double AscendY { get; set; }
       public static double RollX { get; set; }
       public static bool Flying { get; set; }
       public static bool isFlying { get; set; }

        internal static string GetNextCommand(uint sequenceNumber)
        {
            // Determine if the drone needs to take off or land
            if (Flying && !isFlying)
            {
                isFlying = true;
                return DroneMovement.GetDroneTakeoff(sequenceNumber);
            }
            else if (!Flying && isFlying)
            {
                isFlying = false;
                return DroneMovement.GetDroneLand(sequenceNumber);
            }

            // If the drone is flying, sends movement commands to it.
            if (isFlying && (StrafeX != 0 || StrafeY != 0 || AscendY != 0 || RollX != 0))
                return DroneMovement.GetDroneMove(sequenceNumber, StrafeX, StrafeY, AscendY, RollX);

            return DroneMovement.GetHoveringCommand(sequenceNumber);
        }
    }

Свойства StrafeX, StrafeY, AscendYи RollXопределяют соответственно скорость движения влево и вправо, вперед и назад, высоту и угол вращения дрона. Эти свойства имеют тип данных Double, допустимые значения — от 1 до -1. Например, если задать для свойства StrafeXзначение -0,5, то дрон будет перемещаться влево с половиной максимальной скорости; если задать 1, то дрон полетит вправо с максимальной скоростью.

Переменная Flying определяет взлет и посадку. В методе GetNextCommandмы проверяем значения этих полей, чтобы определить, какую команду отправить дрону. Эти команды, в свою очередь, находятся под управлением класса DroneMovement.

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

Самый интересный метод класса DroneMovement — метод GetDroneMove, который фактически и занимается составлением и отправкой команд дрону.  Другие методы, связанные с движением, см. в этом примере.

public static string GetDroneMove(uint sequenceNumber, double velocityX, double velocityY, double velocityAscend, double velocityRoll)
    {
        var valueX = FloatConversion(velocityX);
        var valueY = FloatConversion(velocityY);
        var valueAscend = FloatConversion(velocityAscend);
        var valueRoll = FloatConversion(velocityRoll);

        var command = string.Format("{0},{1},{2},{3}", valueX, valueY, valueAscend, valueRoll);
        return CreateATPCMDCommand(sequenceNumber, command);
    }
private static string CreateATPCMDCommand(uint sequenceNumber, string command, int mode = 1)
    {
        return string.Format("AT*PCMD={0},{1},{2}{3}", sequenceNumber, mode, command, Environment.NewLine);
    }

Метод FloatConversionне указан здесь, но он преобразует значение типа Double диапазона от -1 до 1 в целочисленное значение со знаком, которое может быть использовано АТ-командами, например строкой PCMD для управления движением.

Показанный здесь код доступен в виде бесплатной библиотеки на сайте NuGet (AR.Drone 2.0 Interaction Library). Эта библиотека предоставляет все необходимое для управления — от взлета до посадки.

Пользовательский интерфейс AR.Drone UI на сайте NuGet

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

Intel® RealSense™ SDK

Теперь посмотрим на одну из самых интересных и удобных в использовании (для меня) возможностей Intel RealSense SDK — распознавание речи.

В SDK поддерживается два подхода к распознаванию речи.

• Распознавание команд (по заданному словарю).
• Распознавание свободного текста (диктовка).

Первый подход представляет собой своего рода список команд, заданный приложением, на указанном языке, который обрабатывается «распознавателем». Все слова, которых нет в списке, игнорируются.

Второй подход — что-то типа диктофона, «понимающего» любой текст в свободной форме. Этот подход идеален для стенографирования, автоматического создания субтитров и т. п.

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

Сначала нужно определить некоторые переменные.

        private PXCMSession Session;
        private PXCMSpeechRecognition SpeechRecognition;
        private PXCMAudioSource AudioSource;
        private PXCMSpeechRecognition.Handler RecognitionHandler;

Session — тег, необходимый для доступа к вводу-выводу и к алгоритмам SDK, поскольку все последующие действия унаследованы от этого экземпляра.

SpeechRecognition — экземпляр модуля распознавания, созданного функцией CreateImplв среде Session.

AudioSource — интерфейс устройства, позволяющий установить и выбрать входное аудиоустройство (в нашем примере кода мы для простоты выбираем первое доступное аудиоустройство).

RecognitionHandler — фактический обработчик, назначающий обработчик событий для события OnRecognition.

Теперь инициализируем сеанс, AudioSourceи экземпляр SpeechRecognition.

            Session = PXCMSession.CreateInstance();
            if (Session != null)
            {
                // session is a PXCMSession instance.
                AudioSource = Session.CreateAudioSource();
                // Scan and Enumerate audio devices
                AudioSource.ScanDevices();

                PXCMAudioSource.DeviceInfo dinfo = null;

                for (int d = AudioSource.QueryDeviceNum() - 1; d >= 0; d--)
                {
                    AudioSource.QueryDeviceInfo(d, out dinfo);
                }
                AudioSource.SetDevice(dinfo);

                Session.CreateImpl<PXCMSpeechRecognition>(out SpeechRecognition);

Как было отмечено ранее, для простоты кода мы выбираем первое доступное аудиоустройство.

PXCMSpeechRecognition.ProfileInfo pinfo;
              SpeechRecognition.QueryProfile(0, out pinfo);
              SpeechRecognition.SetProfile(pinfo);

Затем нужно опросить систему, узнать фактический параметр конфигурации и назначить его переменной (pinfo).

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

В нашем случае параметр по умолчанию устанавливается как в профиле 0 (полученном из Queryprofile).

                String[] cmds = new String[] { "Takeoff", "Land", "Rotate Left", "Rotate Right", "Advance","Back", "Up", "Down", "Left", "Right", "Stop" , "Dance"};
                int[] labels = new int[] { 1, 2, 4, 5, 8, 16, 32, 64, 128, 256, 512, 1024 };
                // Build the grammar.
                SpeechRecognition.BuildGrammarFromStringList(1, cmds, labels);
                // Set the active grammar.
                SpeechRecognition.SetGrammar(1);

Затем задаем грамматический словарь для обучения системы распознавания. С помощью BuildGrammarFromStringListмы создаем простой список глаголов и соответствующих возвращаемых значений, определяя грамматику номер 1.

Можно задать несколько грамматик для использования в приложении и включать одну из них при необходимости, поэтому можно создать разные словари команд для всех поддерживаемых языков и предоставить пользователю возможность переключаться между языками, распознаваемыми в SDK. В этом случае нужно установить соответствующие DLL-файлы поддержки языка, поскольку при установке SDK по умолчанию устанавливается поддержка только для языка «Английский (США)». В этом примере мы используем только грамматику, установленную по умолчанию вместе с языком «Английский (США)».

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

                RecognitionHandler = new PXCMSpeechRecognition.Handler();

                RecognitionHandler.onRecognition = OnRecognition;

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

        public void OnRecognition(PXCMSpeechRecognition.RecognitionData data)
        {
            var RecognizedValue = data.scores[0].label;
            double movement = 0.3;
            TimeSpan duration = new TimeSpan(0, 0, 0, 500);
            switch (RecognizedValue)
            {
                case 1:
                    DroneState.TakeOff();
                    WriteInList("Takeoff");
                    break;
                case 2:
                    DroneState.Land();
                    WriteInList("Land");
                    break;
                case 4:
                    DroneState.RotateLeftForAsync(movement, duration);
                    WriteInList("Rotate Left");
                    break;
                case 5:
                    DroneState.RotateRightForAsync(movement, duration);
                    WriteInList("Rotate Right");
                    break;
                case 8:
                    DroneState.GoForward(movement);
                    Thread.Sleep(500);
                    DroneState.Stop();
                    WriteInList("Advance");
                    break;
                case 16:
                    DroneState.GoBackward(movement);
                    Thread.Sleep(500);
                    DroneState.Stop();
                    WriteInList("Back");
                    break;
                case 32:
                    DroneState.GoUp(movement);
                    Thread.Sleep(500);
                    DroneState.Stop();
                    WriteInList("Up");
                    break;
                case 64:
                    DroneState.GoDown(movement);
                    Thread.Sleep(500);
                    DroneState.Stop();
                    WriteInList("Down");
                    break;
                case 128:
                    DroneState.StrafeX = .5;
                    Thread.Sleep(500);
                    DroneState.StrafeX = 0;
                    WriteInList("Left");
                    break;
                case 256:
                    DroneState.StrafeX = -.5;
                    Thread.Sleep(500);
                    DroneState.StrafeX = 0;
                    WriteInList("Right");
                    break;
                case 512:
                    DroneState.Stop();
                    WriteInList("Stop");
                    break;
                case 1024:
                    WriteInList("Dance");
                    DroneState.RotateLeft(movement);
                    Thread.Sleep(500);
                    DroneState.RotateRight(movement);
                    Thread.Sleep(500);
                    DroneState.RotateRight(movement);
                    Thread.Sleep(500);
                    DroneState.RotateLeft(movement);
                    Thread.Sleep(500);
                    DroneState.GoForward(movement);
                    Thread.Sleep(500);
                    DroneState.GoBackward(movement);
                    Thread.Sleep(500);
                    DroneState.Stop();
                    break;
                default:
                    break;

            }
            Debug.WriteLine(data.grammar.ToString());
            Debug.WriteLine(data.scores[0].label.ToString());
            Debug.WriteLine(data.scores[0].sentence);
            // Process Recognition Data
        }

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

Каждая команда дрона относится к вызову DroneStateс определенным методом (TakeOff, GoUp, DoDownи т. д.) и с определенным параметром движения или длительности, который в каждом случае касается определенного количества или длительности движения.

Некоторым командам требуется явный вызов метода Stopдля остановки текущего действия, иначе дрон продолжит двигаться согласно полученной команде (команды см. в предыдущем фрагменте кода).

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

Для проверки распознавания, даже если нет доступного дрона, я вставил переменную (она управляется флажком в главном окне), которая включает функциональный режим Drone Stub (в этом режиме команды создаются, но не отправляются).

Чтобы закрыть приложение, вызовите метод OnClosingдля закрытия и уничтожения всех экземпляров и обработчиков и для общей очистки системы.

В коде содержатся некоторые команды отладки, выводящие полезную информацию в окнах отладки Visual Studio* при тестировании системы.

Заключение

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

Демонстрация полета на конференции .NET Campus в 2014 году

Об авторе

Марко Даль Пино (Marco Dal Pino) работает в области информационных технологий уже свыше 20 лет, сейчас он фрилансер-консультант по платформе .NET. Марко входит в состав DotNetToscana (это сообщество по технологиям Майкрософт) и обладает званием Microsoft MVP в области разработки платформ Windows.  Марко разрабатывает мобильные и встроенные приложения для розничной торговли и корпоративного сектора, а также принимает участие в разработке приложений для Windows 8 и Windows Phone для сторонней компании.

С 2013 года Марко обладает квалификацией Nokia Developer Champion for Windows Phone. В том же году он получил уровень Intel Developer Zone Green Belt корпорации Intel за деятельность по поддержке разработок и популяризации технологии Intel RealSense и управления компьютером без помощи контроллеров. Кроме того, Марко — лауреат сертификатов Intel Software Innovator по технологии Intel RealSense и Интернету вещей.

Он занимается обучением и выступает на крупных технических конференциях.

Марко Минерва (Marco Minerva) работает с платформой .NET с момента появления ее первой версии. Сейчас он главным образом занимается проектированием и разработкой приложений для Магазина Windows и Windows Phone, используя Windows Azure в качестве внутреннего механизма. Марко — один из основателей и руководитель DotNetToscana, находящейся в Тоскане пользовательской группы, работающей с .NET. Марко выступает на технических конференциях и пишет статьи в журналах.

Джекоб Пеннок из компании Livid Interactive предлагает полезные советы по работе с технологиями Intel^® RealSense™и Unity* 5в этом наборе из семи видеороликов. Описание каждого видеоролика см. ниже.

Примечание. В некоторых видеороликах Джекоб ссылается на видео, описывающее модуль распознавания эмоций в составе SDK. Это видео уже недоступно, поскольку модуль распознавания эмоций упразднен и отсутствует в Intel^® RealSense™ SDK, начиная с версии R5.

Настройка набора инструментов Intel^® RealSense™ SDK в Unity* 5

Джекоб описывает, как импортировать набор инструментов Intel RealSense SDKв Unity 5 и проверить правильность установки, используя образец кода с перетаскиванием из Intel RealSense SDK. Примечание. Если установлена версия Intel RealSense SDK R4 или более поздняя, можно пропустить инструкции, касающиеся замены 32-разрядных двоичных файлов на 64-разрядные, поскольку начиная с версии R4 набор инструментов поставляется с 64-разрядным двоичными файлами для Unity 5.

Оптимизация для набора инструментов Intel^® RealSense™ SDK — часть 1

В этом наборе из двух видео, посвященных оптимизации, Джекоб рассказывает об областях набора инструментов Intel RealSense, где производительность недостаточна для рабочего приложения. В первой части описывается значительное повышение кадровой скорости за счет использования SenseToolkitMgr.Update(). Также показано, как устранить проблему зеркалирования в одном из образцов набора инструментов.

Оптимизация для набора инструментов Intel^® RealSense™ SDK — часть 2

Во второй части Джекоб показывает устранение проблемы производительности в методе DrawImages.Update(). В этом видео он создает новый, более эффективно работающий с памятью метод вместо метода Intel, потребляющего слишком много памяти.

Использование Intel^® RealSense™ SDK непосредственно в Unity* 5 (без набора инструментов)

В этом видео говорится о доступе к Intel RealSense SDK непосредственно из кода C# Unity 5. Набор инструментов Intel RealSense может быть полезен для быстрого тестирования, но разработчики могут добиваться более эффективной работы приложений, реализуя собственные способы взаимодействия с Intel RealSense SDK. Джекоб перечисляет основные действия, необходимые для этого.

Альтернативные режимы отслеживания рук в Intel^® RealSense™ SDK и Unity* 5

В составе пакета Intel RealSense SDK есть несколько примеров отслеживания движения рук путем распознавания суставов. В этом виде Джекоб показывает еще одну методику отслеживания рук в режиме Extremities и итоговое сегментированное изображение. Этот метод работает гораздо быстрее, чем отслеживание с распознаванием суставов.

Intel^® RealSense™ SDK + Unity* 5 — полезный совет: отображение сегментированных изображений

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

Intel^® RealSense™ SDK + Unity* 5 — полезный совет: используйте отдельный поток для обновления

Джекоб описывает свой новый ноутбук Asus со встроенной камерой Intel^® RealSense™и показывает, как повысить производительность приложения, используя отдельный поток для взаимодействия с Intel RealSense SDK.

Об авторе

Джекоб Пеннок (Jacob Pennock) — специалист по технологии Intel^® RealSense™. Он занимает должности старшего творческого разработчика в компании Helios Interactive Technologies и главного игрового дизайнера/ведущего разработчика в компании Livid Interactive.

Введение

Технология Intel® RealSense™ поддерживает две разновидности камер глубины: камера переднего обзора, малой дальности (F200) предназначена для установки на ноутбуки, ультрабуки, трансформеры и моноблоки; камера заднего обзора, большой дальности (R200) предназначена для установки на планшеты и в виде отдельного съемного устройства. Обе камеры как выпускаются в виде автономных периферийных устройств, так и встраиваются в компьютерные устройства, доступные на рынке в настоящее время. При использовании технологии Intel RealSense для разработки приложений для таких устройств следует помнить, что принцип взаимодействия с трехмерными приложениями без тактильной обратной связи существенно отличается от модели работы, к которой привыкли разработчики, создающие приложения для сенсорного управления.

В этой статье мы описываем некоторые распространенные принципы и проблемы пользовательских интерфейсов для камер F200 и R200 и показываем, как можно встраивать в приложения визуальную обратную связь с помощью API Intel® RealSense™ SDK.

Рекомендации по созданию пользовательских интерфейсов и использованию API для камеры F200

Результат 1. Понимание объемного пространства съемки и зон взаимодействия для ноутбуков и моноблоков.

Сценарий использования пользовательского интерфейса

Рассмотрим сценарии использования, показанные на рис. 1.

Рисунок 1.Объемное пространство съемки

Пирамида, исходящая из камеры на этом рисунке, представляет собой то, что называется объемным пространством съемки или полем зрения камеры. Для камеры F200 объемное пространство съемки определяется отклонениями от горизонтальной и вертикальной осей камеры, а также эффективным расстоянием между пользователем и камерой. Если пользователь сдвинется за пределы этой пирамиды, камера не сможет отслеживать режим взаимодействия. Ниже для справки приведена таблица с параметрами поля зрения.

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

Почему это важно с точки зрения пользовательского интерфейса? Конечные пользователи понятия не имеют о том, как именно их «видит» камера. Поскольку они знают о зонах взаимодействия, это может привести к раздражению при работе с приложением, поскольку невозможно определить, в чем именно возникла проблема. На изображении слева на рис. 1 рука пользователя находится в поле зрения камера, а на изображении справа — вне поля зрения; в этом случае отслеживание может быть потеряно. Проблема дополнительно осложняется, если в приложении используется управление с помощью обеих рук или сразу несколько режимов управления, например одновременно с помощью лица и рук. Также учитывайте изменение поля зрения камеры при развертывании приложения на устройствах разных типоразмеров, например на ноутбуках и моноблоках: в последнем случае зона взаимодействия будет расположена выше, чем на ноутбуках. На рис. 2 показаны различные сценарии, в которых пользователи находятся перед разными устройствами.

Рисунок 2.Поле зрения камеры и типоразмер устройства

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

Техническая реализация

Пакет Intel RealSense SDK предоставляет API, позволяющие получать данные поля зрения и дальности камеры. API QueryColorFieldOfView и QueryDepthFieldOfView работают в интерфейсе device вне зависимости от типа устройства. Вот как реализуется код.

Хотя возвращаемая структура данных имеет формат PXCPointF32, возвращаемые значения указывают углы X (обзора по горизонтали) и Y (обзора по вертикали) в градусах. Это — заданные производителем значения для данной модели камеры, а не настроенные программно на устройстве.

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

Знание этих API и способов их реализации в коде поможет создать эффективную систему обратной связи для пользователей. На рис. 3 и 4 показаны примеры визуальной обратной связи для объемного пространства съемки.

Рисунок 3.Подсказки о расстоянии до камеры.

Рисунок 4.Схематическое изображение окружающего мира

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

Вместо перечисленных выше API можно использовать оповещения, предоставляемые в каждом SDK для записи определенных действий пользователей. Рассмотрим, к примеру, следующее решение для распознавания лиц. В следующей таблице перечислены оповещения модуля PXC[M]FaceData.

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

SDK также позволяет обнаруживать наложение, т. е. случаи, когда снимаемый объект загорожен посторонним предметом. Описание неподдерживаемых и частично поддерживаемых сценариев см. в документе Руководство по созданию пользовательских интерфейсов для камеры F200. Вне зависимости от того, какой тип наложения вы пытаетесь отслеживать, следующий набор оповещений окажется весьма полезным.

Теперь перейдем к оповещениям в модуле отслеживания рук. Они доступны в модуле PXC[M]HandData в составе SDK. Как видите, некоторые из этих оповещений также неявно задействуют определение дальности (помните о разной дальности действия у модулей распознавания лиц и модулей распознавания рук).

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

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

На рис. 5 и 6 показаны примеры эффективной визуальной обратной связи с помощью оповещений.

На рис. 5 и 6 показаны примеры эффективной визуальной обратной связи с помощью оповещений.

Рисунок 6.Наложение изображения пользователя

Ссылки на API в документации SDK

QueryColorFieldOfView: https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?querycolorfieldofview_device_pxccapture.html

QueryDepthFieldOfView: https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?querydepthfieldofview_device_pxccapture.html

QueryDepthSensorRange: https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?querydepthsensorrange_device_pxccapture.html

Оповещения о поле зрения модуля распознавания лиц:https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?alerttype_alertdata_pxcfacedata.html

Оповещения о поле зрения модуля распознавания рук:https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?manuals_handling_alerts.html

Результат 2. Снижение утомляемости пользователей.

Сценарий использования пользовательского интерфейса: выбор подходящего метода ввода для требуемой точности.

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

Рисунок 7.Выбор правильного способа ввода  

Для выбора элементов в меню можно использовать сенсорное управление или мышь. Режимы ввода, поддерживаемые пакетом Intel RealSense SDK, реализуют непосредственный, естественный механизм взаимодействия без касаний и позволяют создавать увлекательные приложения. Используйте эти режимы таким образом, чтобы не требовалось множества повторяющихся жестов. Для использования жестов лучше всего подходят постоянные действия, в которых ошибки не приведут к нежелательному риску.

Выбор направления движения жестов

Рекомендуется использовать жесты, направленные по горизонтали или по дуге. Если доступен выбор, то для удобства пользователей старайтесь использовать движения по горизонтали вместо движений по вертикали. Помимо этого, не используйте действия, вынуждающие пользователей поднимать руки выше уровня плеч. Помните про эффект «рук гориллы»?

Рисунок 8.Выбор направления движения жестов

Выбор относительного или абсолютного движения

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

Понимание скорости движения

Составной частью проблемы точности является фактор скорости. Если пользователи слишком быстро двигают руками перед камерой, то возникает риск полной потери отслеживания, поскольку при этом руки могут оказаться вне объемного пространства съемки. При использовании в приложениях жестов с быстрыми движениями повышается утомляемость пользователей и увеличивается риск ошибок. Поэтому очень важно учитывать фактор скорости и ее влияние как на эффективную дальностью (вблизи от камеры, на расстоянии от 20 до 55 см, можно обнаруживать быстрое движение со скоростью до 2 м/с), так и на пространство съемки (при небольшом расстоянии от камеры в поле зрения может находиться только одна рука).

Понимание действий пользователя и взаимодействия с объектами

Естественные движения человека не всегда являются плавными: человеческое тело часто двигается неравномерно и рывками, что интерпретируется камерой как несколько разных взаимодействий. При создании приложений для Intel RealSense SDK следует помнить о взаимосвязи между действиями и объектами. Например, если существуют объекты, которые можно «взять» рукой с помощью жестов, следует учитывать размер таких объектов и их расположение, нужно принимать во внимание расстояние до краев экрана и места, куда можно «перетащить» такие объекты, а также способы обнаружения сбоев отслеживания.

Вот несколько рекомендаций, помогающих преодолеть такие проблемы.

• Объекты должны быть достаточно крупными, чтобы на них не влияла дрожь или неравномерное движение руки. Расстояние между объектами должно быть достаточно большим, чтобы пользователи не могли случайно взять не тот объект, который нужно.
• Не располагайте элементы взаимодействия слишком близко к краям экрана, поскольку в этом случае возрастает риск выхода руки пользователя за пределы поля зрения и потери отслеживания, что вызовет у пользователя неминуемое и праведное раздражение.
• Если в интерфейсе важно перетаскивание объектов, то должно быть очевидно, куда именно можно перетащить взятый объект и куда его можно отпустить.
• Если при перемещении пользователем объекта происходит сбой отслеживания, перемещаемый объект должен возвращаться на исходное место, а пользователь должен получить уведомление о сбое отслеживания.

Техническая реализация: скорость и точность

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

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

Поскольку нельзя заставить пользователей двигаться плавно, без рывков, в состав SDK также включена программа Smoother (PXC[M]Smoother), сглаживающая рывки при движении рук перед камерой. Эта программа использует различные линейные и квадратные алгоритмы. Можно поэкспериментировать с ними и выбрать наиболее подходящий. На рис. 9 ниже видно, что неравномерное движение руки в значительной степени сглаживается этой программой.

Рисунок 9. Данные со сглаживанием и без сглаживания

Еще один способ обнаружить слишком быстрое движение руки — перечисление TRACKINGSTATUS_HIGH_SPEED в свойстве PXCMHandData.TrackingStatusType. При обнаружении лица быстрые движения могут привести к потере отслеживания. Используйте PXCMFaceData.AlertData.AlertType — ALERT_FACE_LOST, чтобы определять утраченное отслеживание. Если же вы используете жесты рук для управления операционной системой с помощью Touchless Controller, используйте функции SetPointerSensitivity и SetScrollSensitivity в PXC[M]TouchlessController для настройки чувствительности указателя и прокрутки.

Ограничительные рамки

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

Модули отслеживания лица и рук в SDK поддерживают API PXCMHandData.IHand.QueryBoundingBoxImage, который возвращает расположение и размеры отслеживаемой руки (двухмерную ограничительную рамку), на карте глубины. API PXCMFaceData.DetectionData.QueryBoundingRect возвращает ограничительную рамку обнаруженного лица. Также можно использовать PXCMHandData.AlertType — ALERT_HAND_OUT_OF_BORDERS, чтобы обнаруживать выход руки за пределы ограничительной рамки.

Ссылки на API в документации SDK

Алгоритм отслеживания Blob:https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?manuals_blob_tracking.html

EnableJointSpeed:https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?enablejointspeed_pxchandconfiguration.html

Программа Smoother:https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?manuals_the_smoother_utility.html

TouchlessController:https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?pxctouchlesscontroller.html

SetPointerSensitivity и SetScrollSensitivity:https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?member_functions_pxctouchlesscontroller.html

Рекомендации по созданию пользовательских интерфейсов и использованию API для камеры R200

Камера R200 встраивается в планшеты и выпускается в виде съемного устройства. Она предназначена для съемки пространства вокруг пользователя. Среди возможных сценариев использования камеры R200 следует отметить такие решения, как дополненная реальность и съемка всего тела человека. В поле зрения этой камеры попадает окружающий мир, поэтому сущность и набор проблем проектирования пользовательских интерфейсов отличаются от описанных выше для камеры F200. В этом разделе описываются некоторые известные проблемы пользовательских интерфейсов, связанные с модулем Scene Perception (который будет использоваться разработчиками в приложениях дополненной реальности) и с модулем 3D Scanning.

Результат 1. Понимание объемного пространства съемки и зон взаимодействия для планшетов

Сценарий использования пользовательского интерфейса

Как видно на рис. 10, углы обзора камеры R200 по вертикали и по горизонтали, а также дальность ее действия значительно отличаются от аналогичных характеристик камеры F200. Камеру R200 можно использовать в двух разных режимах: в активном режиме (когда пользователь передвигается, снимая сцену) и в пассивном режиме (когда пользователь работает с неподвижным изображением). При съемке объекта или сцены убедитесь, что объект находится в поле зрения камеры, пока пользователь снимает его в активном режиме. Также учтите, что дальность действия этой камеры (в зависимости от того, где она используется: в помещении или на улице) отличается от дальности камеры F200. Как получить эти точки данных во время выполнения, чтобы предоставить пользователю визуальную обратную связь?

Рисунок 10.Объемное пространство съемки камеры R200

Техническая реализация

Мы уже обсудили API QueryColorFieldOfView() и QueryDepthFieldOfView() выше в разделе, посвященном камере F200. Эти функции не зависят от устройства, с их помощью можно производить объемную съемку и камерой R200. Тем не менее для обнаружения дальности действия камеры R200 нужно использовать специализированный API, предназначенный только для этого устройства. Чтобы получить такие данные для камеры R200, необходимо использовать API QueryDSMinMaxZ, доступный в составе интерфейса PXCCapture. Он возвращает минимальную и максимальную дальность камеры в миллиметрах.

Ссылки на API в документации SDK

QueryDSMinMaxZ: https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?querydsminmaxz_device_pxccapture.html

Результат 2. Понимание действий пользователя и взаимодействия со сценой.

Сценарий использования пользовательского интерфейса: планирование с учетом особенностей сцены и возможностей камеры

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

Техническая реализация

Модули Scene Perception и 3D Scanning обладают разными требованиями, а поэтому в них используются разные механизмы для обнаружения минимальных требований.

• Scene Perception.Всегда используйте API CheckSceneQuality в модуле PXCScenePerception, чтобы определить, пригодна ли сцена для отслеживания. API возвращает значение между 0 и 1. Чем выше возвращенное значение, тем лучше сцена для отслеживания. Вот как реализуется код:

После того как качество сцены будет сочтено удовлетворительным и начнется отслеживание, следует динамически проверять состояние отслеживания с помощью API TrackingAccuracy в модуле PXCScenePerception. Этот API выдает точность отслеживания.

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

• 3D Scanning Алгоритм 3D Scanning предоставляет оповещения, показанные в приведенной ниже таблице. Для получения этих данных используйте PXC3DScan::AlertEvent.

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

• Образец учебной программы при запуске.
• Рисунок 11.Обучение
• Предварительный просмотр снятой области или предмета.
  
• Рисунок 12.Предварительный просмотр
• Подсказки для пользователя.
  
• Рисунок 13. Подсказки для пользователя

Снижение утомляемости в случае, когда пользователь держит устройство в руках

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

Рисунок 14.Использование устройства в активном и в неактивном режимах

Выбор подходящего режима для действия

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

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

Рисунок 15.Зоны касаний в активном и в неактивном режимах

Ссылки на API в документации SDK

Настройка API Scene Perception и данные отслеживания:https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?manuals_configuration_and_tra2.html

Оповещения API 3D Scanning:https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?alertevent_pxc3dscan.html

Заключение

При разработке приложений с использованием технологии Intel® RealSense™ разработчики должны с самых ранних этапов принимать во внимание потребности и особенности работы конечных пользователей. Рекомендации, приведенные в этой статье, послужат основой для решения некоторых важных проблем пользовательских интерфейсов и для реализации необходимых компонентов в коде с помощью SDK.

Дополнительные материалы

Рекомендации по созданию пользовательских интерфейсов для камеры F200: https://software.intel.com/sites/default/files/managed/27/50/Intel%20RealSense%20SDK%20Design%20Guidelines%20F200%20v2.pdf

Рекомендации по созданию пользовательских интерфейсов для камеры R200:

https://software.intel.com/sites/default/files/managed/d5/41/Intel%20RealSense%20SDK%20Design%20Guidelines%20R200%20v1_1.pdf

Лучшие методики создания пользовательских интерфейсов в приложениях для камеры F200:

https://software.intel.com/en-us/articles/best-ux-practices-for-intel-realsense-camera-f200-applications

Ссылка на презентацию и запись выступления на конференции IDF:

http://myeventagenda.com/sessions/0B9F4191-1C29-408A-8B61-65D7520025A8/7/5

Об авторах

Мегана Рао (Meghana Rao)

Мегана — разработчик-евангелист в отделе Software and Services корпорации Intel, она сотрудничает с разработчиками и независимыми производителями программного обеспечения, помогая им в использовании технологии Intel® RealSense™ и в разработке приложений для Windows* 8 на ультрабуках, трансформерах и планшетах с архитектурой Intel®. Кроме того, она регулярно выступает на семинарах Intel Application Labs, где рассказывает о проектировании и разработке приложений на платформах Intel. Мегана Рао является автором множества информационных документов, доступных на портале Intel® Developer Zone. Она обладает ученой степенью бакалавра в области компьютерных наук и ученой степенью магистра в области компьютерных наук и управления технологиями. До поступления на работу в корпорацию Intel в 2011 году она работала старшим инженером по программному обеспечению в компании Infineon Technologies India Pvt. Ltd.

Кевин Артур (Kevin Arthur)

Кевин Артур — старший исследователь взаимодействия с пользователями в отделе Perceptual Computing корпорации Intel. Он руководит исследованиями новых сценариев использования и рекомендаций по работе с трехмерными камерами RealSense, включая смешанные сценарии и дополненную реальность. Кевин получил ученую степень доктора компьютерных наук в Университете Северной Каролины в г. Чапел-Хилл, его специальность — взаимодействие человека и компьютера в системах виртуальной реальности. Ранее он занимался разработкой пользовательских интерфейсов и исследованиями программного обеспечения в компаниях Amazon Lab126, Synaptics и Industrial Light & Magic.

Введение

В версии Intel® RealSense™ SDK R5 (v7) наконец-то появилась долгожданная поддержка разработки приложений для универсальной платформы Windows (UWP), и эта статья поможет приступить к работе. Краткий обзор интерфейсов и методов UWP был представлен в документации к выпуску R4, а в выпуске R5 появились программные компоненты, документация и образцы кода, необходимые для разработки приложений UWP, использующих камеру Intel® RealSense™ SR300.

Как указано в статье Новые возможности выпуска Intel® RealSense™ SDK R5 (v7), камеру SR300 можно заказать начиная с I квартала 2016 года. Кроме того, эта камера будет встраиваться в некоторые устройства с процессорами Intel в 2016 году. Поскольку камера SR300 пока недоступна для конечных пользователей, эта статья посвящена главным образом тем вещам, с которыми следует ознакомиться перед началом работы с новым выпуском и с этой камерой.

Что потребуется для начала работы

• Ноутбук или ПК с операционной системой Microsoft Windows 10
• Microsoft Visual Studio* 2015 и Microsoft Windows 10 Developer Tools
• Камера Intel RealSense SR300 (заказы на эти камеры принимаются с I квартала 2016 г.)
• Intel RealSense SDK R5 (v7)
• SR300 DCM 3.0 Gold (можно получить только через Центр обновления Windows)

Область и ограничения SDK

• SDK поддерживает разработку приложений UWP для Windows 10 с помощью C# и XAML.
• Для приложений UWP в SDK поддерживается только передача необработанного цветного изображения и карты глубины, а также алгоритм отслеживания Blob. Прочие алгоритмы, касающиеся UWP, пока находятся на этапе разработки.
• Приложения UWP должны статически включать файлы среды выполнения SDK, чтобы версия SDK была зафиксирована во время разработки.
• Интерфейс Session не раскрывается явно в UWP C#.
• Система координат камеры в приложениях UWP слегка отличается, дополнительные сведения см. в руководстве по SDK.
• Невозможно изменить систему координат в приложении UWP.
• Для сопоставления координат между потоками цветного изображения и глубины в приложениях UWP используйте интерфейс Windows.Devices.Perception.PerceptionDepthCorrelatedCoordinateMapper.
• В руководстве по SDK отметка (UWP)означает интерфейсы и методы, относящиеся к UWP. Отметка (+UWP)указывает, что данный интерфейс UWP входит в состав функции вместе с интерфейсами других языков.

Примеры классических приложений для Windows

После установки DCM и SDK перезагрузите компьютер, затем убедитесь в правильной работе камеры, запустив один из примеров в Intel RealSense SDK Sample Browser.

Нажмите в Windows 10 кнопку «Пуск» в левом нижнем углу экрана.

Выберите Все приложенияи найдите папку Intel RealSense SDK (рис. 1).

Рисунок 1. Меню «Пуск» в Windows

Найдите и запустите Intel RealSense SDK Sample Browser. В верхней части окна SDK Sample Browser (рис. 2) находится вкладка SR300 Samples, содержащая все примеры классических приложений для Windows (т. е. приложений, работающих в классическом режиме Windows, а не в виде приложений UWP). Ознакомьтесь с этими приложениями для изучения всех возможностей камеры SR300.

Рисунок 2. SDK Sample Browser

Компоненты UWP

Программные компоненты UWP в составе Intel RealSense SDK находятся в папке C:\Program Files (x86)\Intel\RSSDK\UWP. (Примечание. Это путь установки по умолчанию. В вашем случае путь может различаться в зависимости от того, в какую папку был установлен пакет SDK.) Компоненты находятся в следующих вложенных папках внутри папки \UWP:

• \ExtensionSDKs — DLL-библиотеки, на которые ссылаются приложения UWP.
• \Samples  — образцы кода DF_BlobViewer_UWP_CS и DF_StreamViewer_UWP_CS.

Создание проекта UWP с нуля

Если вы впервые занимаетесь разработкой приложений UWP, то сначала следует освоить основы создания проектов UWP с нуля. Информативный учебный проект Hello, world! на C#/XAML доступен на этом веб-сайте Microsoft.

Этот учебный проект поможет узнать, как создать простое приложение, предназначенное для UWP и Windows 10. После выполнения учебного проекта Hello, world! и запуска нового приложения UWP оно будет выглядеть примерно так, как показано на рис. 3.

Рисунок 3. Приложение UWP Hello, world!

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

#if DEBUG

        if (System.Diagnostics.Debugger.IsAttached)

        {

            this.DebugSettings.EnableFrameRateCounter = true;

        }

#endif

Можно либо задать для этого свойства значение false:

this.DebugSettings.EnableFrameRateCounter = false;

Либо просто закомментировать эту строку кода:

// this.DebugSettings.EnableFrameRateCounter = true;

Настройка среды разработки для камеры Intel®RealSense™

Чтобы приложение могло использовать камеру Intel RealSense, выполните следующие действия:

• Установите флажок Веб-камерав разделе «Возможности» в окне «Манифест приложения».
• Добавьте ссылки на библиотеки Intel RealSense SDK.

В обозревателе решений дважды щелкните Package.appxmanifest, затем перейдите на вкладку Возможности.

Найдите и установите флажок Веб-камера, как показано на рис. 4.

Рисунок 4. Package.appxmanifest

Теперь нужно добавить ссылки на библиотеки Intel RealSense SDK.

• Intel.RealSense — эта библиотека содержит основную реализацию экземпляров в SDK, в том числе для управления алгоритмами и для поточной передачи данных с камер.
• Intel.RealSense.Blob — эта библиотека содержит реализацию модуля отслеживания Blob в SDK.

Щелкните правой кнопкой мыши Ссылкив обозревателе решений и выберите Добавить ссылку, чтобы открыть диспетчер ссылок.

Нажмите кнопку Обзори перейдите в папку, содержащую файлы Intel.RealSense.winmdи Intel.RealSense.Blob.winmd. (Эти файлы метаданных находятся в папке C:\Program Files (x86)\Intel\RSSDK\UWP\ExtensionSDKs\.)

Нажмите кнопку Добавить. Эти библиотеки появятся в разделе «Ссылки» в обозревателе решений.

Изучение примеров UWP

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

• DF_BlobViewer_UWP_CS
• DF_StreamViewer_UWP_CS

Примечание. Эти примеры недоступны в приложении SDK Sample Browser, описанном выше. Они находятся в папке C:\Program Files (x86)\Intel\RSSDK\UWP\Samples, их следует скопировать в любую доступную для записи папку, чтобы скомпилировать в Visual Studio 2015.

Заключение

В этой статье приводится краткая сводка по разработке приложений UWP с помощью Intel RealSense SDK. Следите за новостями по мере выпуска камеры SR300.

Об авторе

Брайан Браун — инженер по разработке программных приложений в подразделении Developer Relations корпорации Intel. 

Рисунок 1. Windows* 10 — это общая операционная система
для целого ряда устройств

В Windows 10 реализован целый ряд новых и улучшенных возможностей. Кроме того, эта операционная система должна объединить широчайший диапазон игровых платформ с приложениями универсальной платформы Windows (UWP). Благодаря расширенной поддержке устройств-трансформеров можно использовать более естественные режимы взаимодействия. Поскольку все платформы работают под управлением вариантов одной и той же операционной системы, все приложения устанавливаются из одного и того же магазина. Что касается игр для ПК, то возможности их установки еще лучше благодаря поддержке Steam*. Каким бы ни был способ установки игр, DirectX* 12 вдохнет в них новую жизнь за счет существенно расширенных возможностей.

Потенциал DirectX 12

DirectX 12 — это самая последняя версия графического пакета API корпорации Microsoft, предназначенного для управления и оптимизации функций мультимедиа, и в частности для обработки графики в играх. Более того, игровые консоли Xbox* произошлиот первоначально задуманного DirectX Box. Неудивительно, что эта технология по-прежнему является фундаментальной для разработки игр.

Рисунок 2. Благодаря DirectX* 12 на ПК можно реализовать
оптимизацию уровня игровых консолей

В DirectX 12 под управлением Windows 10 реализован целый ряд усовершенствований, снижены издержки при вызовах, использование файла подкачки памяти и потребление ресурсов, благодаря чему игра получает больше ресурсов ЦП и памяти. Игры в режиме переднего плана получают более полный контроль над выполнением их процесса; применяется резервирование памяти, чтобы исключить подкачку текстур и другие потенциальные конфликты с внешними приложениями. Если обойтись без более подробных объяснений, эти усовершенствования обеспечивают пользователю более удобные возможности и позволяют запускать игру на большем количестве компьютеров разной мощности, поддерживая при этом приемлемую производительность.

Одна из важнейших проблем, связанных с появлением любой новой технологии, состоит в том, какую долю существующих материалов и процессов разработки придется переделать для поддержки новой технологии. К счастью, при переходе с DirectX 11 на DirectX 12 процессы остаются неизменными. Можно использовать прежние текстуры и модели, форматы, цели рендеринга, вычислительные модели и т. д. Наиболее важные изменениякасаются кода настраиваемых игровых движков, причем в сети MSDN опубликованы официальные инструкциипо переводу этих движков на новую версию. В большинстве случаев разработчики используют существующий движок, поддержка DirectX 12 уже реализована в Unreal* и Unity* (в частности, со значительным ускорением за счет распределения нагрузки на несколько ядер процессора, но будут и другие усовершенствования). Если учесть встроенную поддержку DirectX 12 в процессорах Intel^®  Core™ 6-го поколения, это даст возможность игровым движкам эффективно использовать все ресурсы системы.

Распространение через Steam

Steam — ведущаясистема распространения игр для ПК. С помощью Steam геймеры узнают о новых играх, приобретают и устанавливают их. Кому-то может показаться странным, что корпорация Microsoft поддерживает внешний магазин приложений (вместо своего собственного), но здесь нет конкуренции в одной и той же области: магазин приложений для Windows предназначен для всех устройств под управлением Windows (по данным за прошлый год, их количество превысило 1,5 миллиарда), чтобы можно было покупать приложения на смартфоне, находить и загружать игры для Xbox One и ПК.

Геймеры не будут столь охотно переходить на новую ОС, если окажется, что большая часть их игровой библиотеки содержится в программе, которая может не поддерживаться. К счастью, Steam* в Windows 10 обладает полной обратной совместимостью и не требует никаких изменений (помимо обновления драйверов видеоадаптера).

Существует даже плитка Steam, чтобы создавать плитки для быстрого доступа к отдельным играм. Корпорация Microsoft стремится обеспечить безупречную работу Steam в Windows 10, и это приносит свои плоды: согласно проведенному в Steam анализу оборудования, Windows 10 стала второй по распространенности операционной системой в Steam. Более четверти пользователей перешли на эту ОС в течение всего нескольких месяцев после ее выпуска.

Рисунок 3. Уступая лишь операционной системе Windows* 7 (44,86 %), операционная система Windows 10 продолжает распространяться (ее доля составляет 27,42 %) с темпами, равными суммарным темпам распространения всех остальных операционных систем

Гибкость на трансформерах

Современные устройства-трансформеры могут использоваться как в режиме планшета, идеально подходящего для мобильных игр, так и в режиме ноутбука с высококачественной графикой и высокой производительностью, необходимой для игр на ПК. Сочетание гибких возможностей сенсорного экрана и ноутбука предоставит геймерам универсальное решение с идеальными методами взаимодействия для разных задач. Возможности пользователей по управлению в играх дополнительно расширяются с помощью таких решений, как Intel^®  RealSense™ SDK, поддерживающих использование на персональных компьютерах трехмерных камер и голосовых команд (вот краткое руководствопо использованию этой технологии в Windows 10).

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

Интеграция всего мира Windows

Концепция «Написать код приложения один раз и запускать его на любых системах», ранее считавшаяся идеалом, становится более достижимой благодаря распространению приложений для универсальной платформы Windows (UWP). Корпорация Майкрософт проводит стандартизацию всех платформ под знаменами Windows 10, образуя тем самым великолепную возможность для многократного использования кода. Разумеется, у разработчиков по-прежнему есть возможность написать разные версии для разных платформ, но теперь можно написать код игры, которая будет работать на ПК, игровых консолях Xbox One, планшетах, смартфонах и даже очках виртуальной реальности HoloLens*, сможет охватывать целые семейства устройств со схожими аппаратными ресурсами.

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

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

Существует целый ряд ресурсов с технической информацией, например материалы Майкрософт на конференции GDC 2015, касающиеся многих аспектов, не раскрытых в этой статье: Крис Тектор (Chris Tector) и Дон Бокс (Don Box)рассказывают о работе систем в этой парадигме, Билл Шифельбайн (Bill Schiefelbein)демонстрирует участие геймеров и разработчиков игр в новом виде социальной сети на основе приложения Xbox, Виджей Гаджала (Vijay Gajjala) и Брайан Тайлер (Brian Tyler)рассказывают об использовании API Xbox Live для быстрого применения этих новых возможностей, а Крис Карла (Chris Charla)представляет программу для независимых разработчиков ID@XBOX, дающую возможность самостоятельной публикации наравне с остальными (включая даже бесплатное получение двух комплектов разработчика при наличии адреса электронной почты на веб-сайте компании).

Подключение через приложение Xbox

Приложение Xbox (игровой центр на ПК, распространяющий функциональность Xbox Live на другие устройства) объединяет воедино все игровые возможности. Это приложение объединяет друзей-геймеров в подобие интересной, динамичной и увлекательной социальной сети, способствуя развитию культуры игроков.

Рисунок 4. Приложение Xbox* расширяет возможности геймеров

Игроки могут записывать видеоролики и делать снимки экрана в своих играх, чтобы обмениваться ими друг с другом. Дополнительная возможность — запись последних 30 секунд игрового процесса на случай, если вдруг произойдет что-то интересное, но непредвиденное. Поскольку сеть друзей и подписчиков распространяется на разные платформы, любая игра получает одинаковый уровень распространения: даже пользователи, запускающие приложение Xbox на мобильном устройстве, смогут смотреть видеоролики, снятые в игре.

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

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

В Центре разработчиков Windowsпредоставляются панели мониторинга для аналитики, отслеживания информации, такой как данные игроков и покупки; можно динамически создавать различные элементы для привлечения внимания, например достижения, конкурсы и таблицы лидеров. При наличии у разработчиков всей этой информации игроки смогут раскрывать для себя новые аспекты игр и по-новому общаться со своими друзьями в игре.

Дополнительно: передача с Xbox One на ПК

Игровая консоль Xbox One дает возможность не только играть и общаться с друзьями на разных платформах, но и передавать игровой процесс на любой ПК с Windows 10, находящийся в этой же сети. Разумеется, необходимо учитывать ряд особенностей, чтобы обеспечить удобство игры в этом случае, но сама возможность играть без привязки к телевизору очень важна.

Рисунок 5. Передача игры в любое место сети

Обоюдная польза

Если вы — геймер или разработчик игр для ПК или Xbox One, то операционная система Windows 10 окажется вам очень полезна. Возможности, предоставляемые приложением Xbox и интерфейсами API, закладывают основу для более широкого и глубокого привлечения игроков. Новая версия решений Майкрософт отвечает всем требованиям игроком в отношении производительности и простоты использования, чтобы сделать игры более увлекательными и интересными на всех уровнях.

Дополнительные сведения

Происхождение названия Xbox: http://www.economist.com/node/5214861

DirectX 12: http://blogs.msdn.com/b/directx/archive/2014/03/20/directx-12.aspx

Значение DirectX 12 для геймеров и разработчиков: http://www.pcgamer.com/what-directx-12-means-for-gamers-and-developers/

Важные различия между Direct 3D 11 и Direct 3D 12: https://msdn.microsoft.com/ru-ru/library/windows/desktop/dn899194(v=vs.85).aspx

Преобразование приложений с Direct3D 11 на Direct 3D 12: https://msdn.microsoft.com/ru-ru/library/windows/desktop/mt431709(v=vs.85).aspx

Теперь все разработчики могут выпускать игры DirectX 12 с помощью обновленного движка Unreal Engine 4: http://www.windowscentral.com/any-developer-can-now-make-directx-12-game-updated-unreal-engine-4

Основатель Unity: сам по себе API DirectX 12 не дает заметного прироста производительности: http://gamingbolt.com/unity-founder-directx-12-api-alone-doesnt-give-a-significant-performance-boost

Описание продукта. Платформа процессоров Intel^®  Core™ 6-го поколения:  http://www.intel.com/content/www/ru/ru/processors/core/6th-gen-core-family-mobile-brief.html

Valve собирает партнеров по игровым консолям для конкуренции с Microsoft и Sony: http://www.bloomberg.com/news/articles/2013-11-04/valve-lines-up-console-partners-in-challenge-to-microsoft-sony

Магазин Microsoft Xbox не пытается убрать Steam из Windows 10: http://venturebeat.com/2015/05/21/microsofts-xbox-store-isnt-trying-to-cut-out-steam-in-windows-10/

Корпорация Майкрософт: на рынке насчитывается полтора миллиарда устройств с Windows: http://www.neowin.net/news/microsoft-we-have-15-billion-windows-devices-in-the-market

Плитка Steam:   https://www.microsoft.com/ru-ru/store/apps/steam-tile/9wzdncrfhzkv

Майкрософт стремится поддерживать Steam и «помочь безупречно работать под управлением Windows 10»: http://www.technobuffalo.com/2015/08/07/microsoft-wants-to-support-steam-and-help-it-run-great-on-windows-10/

Обзор оборудования и программного обеспечения Steam, ноябрь 2015 г.: http://store.steampowered.com/hwsurvey

Intel RealSense: http://www.intel.com/content/www/ru/ru/architecture-and-technology/realsense-overview.html

Приступая к разработке приложений Intel^®  RealSense™ SDK для настольных ПК с Windows* 10: https://software.intel.com/ru-ru/articles/get-started-developing-intel-realsense-sdk-for-windows-10-desktop-apps

Windows 10 на Surface Pro 3 — идеальный трансформер: http://www.gizmag.com/windows-10-surface-pro-3-review/38189/

Что такое приложение для универсальной платформы Windows (UWP): https://msdn.microsoft.com/ru-ru/library/windows/apps/dn726767.aspx

Динамическое обнаружение компонентов с помощью контрактов API (10 из 10): https://blogs.windows.com/buildingapps/2015/09/15/dynamically-detecting-features-with-api-contracts-10-by-10/

Универсальность: понимание жизненного цикла приложений для Windows 10: https://visualstudiomagazine.com/articles/2015/09/01/its-universal.aspx

MSDN Channel 9, конференция GDC 2015: https://channel9.msdn.com/Events/GDC/GDC-2015

Разработка игр для Windows 10: https://channel9.msdn.com/Events/GDC/GDC-2015/Developing-Games-for-Windows-10

Игровые возможности конечных пользователей в Windows 10: https://channel9.msdn.com/Events/GDC/GDC-2015/Gaming-Consumer-Experience-on-Windows-10

Разработка с Xbox Live для Windows 10: https://channel9.msdn.com/Events/GDC/GDC-2015/Developing-with-Xbox-Live-for-Windows-10?ocid=SessionsInEvent

Новые возможности для независимых разработчиков: https://channel9.msdn.com/Events/GDC/GDC-2015/New-Opportunities-for-Independent-Developers?ocid=SessionsInEvent

Возможности Xbox в Windows 10: http://www.xbox.com/ru-ru/windows-10/xbox-app

Центр разработчиков Windows: https://dev.windows.com/ru-ru/games

Использование поточной передачи игр в приложении Xbox под управлением Windows 10: https://support.xbox.com/ru-ru/xbox-on-windows/gaming-on-windows/how-to-use-game-streaming

Об авторе

Брэд Хилл (Brad Hill) — инженер по программному обеспечению в подразделении Developer Relations корпорации Intel. Брэд занимается изучением новых технологий на оборудовании Intel и обменивается лучшими методиками с разработчиками ПО на форумах Intel^®  Developer Zone и на конференциях разработчиков. Он помогает студентам и разработчикам становиться разработчиками игр и изменять мир к лучшему.