49391

Прибор для исследования оптических приборов

Курсовая

Коммуникация, связь, радиоэлектроника и цифровые приборы

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

Русский

2013-12-26

5.26 MB

1 чел.

58

Министерство общего и профессионального

образования Российской Федерации

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

Кафедра Информатики и Вычислительной Техники

Пояснительная записка к курсовой работе

«Прибор для исследования оптических приборов»

Выполнил: студент группы ИВТ-297

Басаргин А.С.

Принял: Дубов И.Р.

Владимир, 1999
Разработка программной системы: «Прибор для исследования оптических приборов»

  1.  Содержание

[0.1] Содержание

[0.2]
АННОТАЦИЯ

[0.3] Формулировка задачи

[0.4]
СИСТЕМНЫЙ АНАЛИЗ

[0.4.1] Словарь системной области

[0.4.2] Техническое задание на проектирование

[0.4.2.1] Функции системы

[0.4.2.2] Диаграмма классов

[0.4.2.3] Диаграмма объектов, видимость объектов

[0.4.2.4] Эксплуатационные требования

[0.5] Проектирование программной системы

[0.5.1] Идентификация классов и объектов

[0.5.2] Идентификация содержания классов

[0.5.3] Идентификация связей между классами и объектами

[0.5.4] Реализация классов и объектов

[0.6] ПРОГРАММИРОВАНИЕ

[0.7] ТЕСТИРОВАНИЕ

[0.8] ЗАКЛЮЧЕНИЕ

[0.9]
ПРИЛОЖЕНИЕ 1

[0.9.1] //Figures.h - Интерфейс модуля графических фигур

[0.9.2] // Figures.cpp - Реализация модуля графических фигур

[0.9.3] // Optic.h - Заголовок модуля элементов оптической системы

[0.9.4] // Optic.cpp - Реализация модуля элементов оптической системы

[0.9.5] // main.cpp - головная программа системы "Оптика"

[0.10] ПРИЛОЖЕНИЕ 2

[0.10.1] // Проект "Оптика". Драйвер для тестирования подпрограммы.

[0.11] ПРИЛОЖЕНИЕ 3

[0.11.1]  Листинг тестирования

[0.12] СПИСОК ЛИТЕРАТУРЫ

  1.  
    АННОТАЦИЯ

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

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

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

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

  1.  Формулировка задачи

Это задание является упрощенным вариантом из примера [Буч]. Моделируется установка, состоящая из источника света, оптического стола (линейка с делениями, показывающими расстояние от источника) и набора из  четырех линз (2е собирающие и 2е рассеивающие) с различными фокусными расстояниями.

Функция модели – изображение пути лучей, проходящих через линзы, расположенные на оптической скамье.

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

  1.  
    СИСТЕМНЫЙ АНАЛИЗ

  1.  Словарь системной области

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

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

 · Оптический стол (TTable)

 ¨ Атрибуты:

 Оптическая скамья

 Источник света

 ¨ Действия:

 Начать моделирование результирующего изображения (Start)  

 Начальная расстановка вещей на столе (Initiate)

 · Оптическая скамья (TRuler)

 ¨ Атрибуты:

 Две рассеивающие линзы

 Две собирающие линзы

 Длинна (theLength)

 ¨ Сообщения другим объектам:

 Выбрать линзу (ChooseLens)

 · Линза (TLens)

 ¨ Атрибуты:

 Положение (theLocation)

 Радиус (theRadius)

  Расстояние от начала линейки (theDistance)

 Фокусное расстояние (theFocus)

 ¨ Действия:

Установить положение относительно начала линейки (SetDistance)

Изменить положение линзы (ChangeLocation)

 ¨ Сообщения другим объектам:

    Сообщить положение относительно начала линейки (GetDistance)         Отклонить луч света (DivergeRay)

 · Рассеивающая линза (TDispersiveLens)

 · Собирающая линза (TCollectiveLens)

 · Луч света (TRay)

 ¨ Атрибуты:

 Направление (theDirection)

 · Источник света (TLightSource)

 ¨ Атрибуты:

  Луч света

 Высота над центральной осью (theAltitude)

 Количество испускаемых лучиков (theRaiesNumber)

 ¨ Действия:

 «Пустить» лучи (LetsGoRaies)

 Изменить высоту над центральной осью (ChangeAltitude)

 · Моделируемая действительность (TReality)

 ¨ Атрибуты:

  Оптический стол

 ¨ Действия:

 Начать моделирование результирующего изображения (Run)

 

 К полученному словарю предметной области следует добавить следующие замечания. Все линзы имеют одинаковые характеристики поведения, поэтому классы TDispersiveLens и TCollectiveLens являются подклассами одного класса TLens. Строго говоря, моделируемый оптический стол не является замкнутой системой, он входит в состав более широкого понятия – моделируемая действительность. Это проявляется в том, что, вводится метод Start класса TTable. Поэтому вводиться понятие «моделируемая действительность» как объект theReality класса TReality. Об этом объекте, на данном этапе проектирования, известно лишь то, что он воздействует на моделируемый оптический стол в процессе моделирования (Run).

Параметр (theLength) класса TRuler «длина линейки» определяется как число пикселей, составляющих оптический стол (линейку) и зависит от конкретного графического режима.

Параметр theLocation класса TLens «положение линзы» задает ее местоположение в системе, т.е. либо на линейке, либо «на полке»1.

Параметр (theDirection) класса TRay «направление луча» определяется аналогично реальной модели – вектором в пространстве, т.е. зависит от трех координат.

Абстракция поведения «начать моделирование результирующего изображения» означает, что источник света начнет «пускать лучи» в интервале направлений краешков первой линзы, причем отсеченные лучи рассматривать в дальнейшем я не буду, а перейду к обработке тех лучей, которые будут искривлены линзой. Т.к. источник света принимается точеным, то лучей будет не менее двух: нижнего и верхнего. Отсюда следует, что для объекта класса TLightSource  определена операция: «пустить лучи» (LetsGoRaies).

  1.  Техническое задание на проектирование

Функции системы 

  •  запуск на моделирование осуществляется при помощи команд, подаваемых с клавиатуры: начать моделирование (либо клавиша «S», либо включенный режим RealTime), завершить работу программы (клавиша «Q»);
  •  изменение высоты источника света, добавление и удаление линз осуществляется посредством клавиш: («вверх», «вниз»). Перемещение линз – посредством клавиш: («вправо», «влево»);
  •  выбор объекта для изменения  параметров: (клавиша «Tab»).
  •  отображение на экране дисплея перемещений светового луча;
  •  отображение на экране результатов пересечений светового луча и линзы;
  •  отображение на экране мнимых фокусов, полученных в результате пересечения луча и рассеивающей линзы.

    рис. 1. «Диаграмма классов на стадии анализа»

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

См. рис. 1. «Диаграмма классов на стадии анализа». Согласно рис.1:

  •  реализация класса TReality  использует класс TTable (см. пояснения в словаре системной области);
  •  реализация класса TTable использует классы TLightSource, TRuler;
  •  реализация класса TRuler использует классы TDispersiveLens, TCollectiveLens и пользуется интерфейсной частью TLens;
  •  реализация класса TLightSource использует класс TRay;
  •  класс TLightSource являются наследником класса TLens и использует класс TRay.

Диаграмма объектов, видимость объектов

Для уточнения структуры классов детально рассмотрим механизмы взаимодействия объектов с определением в явном виде их взаимной видимости (см. рис. 2 «Диаграмма объектов на стадии анализа»).

  •  объект theTable класса TTable является полем объекта theReality и получает сообщение Start() (см. выше);
  •  объект aRuler класса TRuler является полем объекта theTable, получает сообщение ChooseLens() (см. выше), и посылает сообщение ChangeLocation() текущей линзе, т.е. объекту aLens;
  •  объект aLightSource класса TLightSource является полем объекта theTable и получает сообщения LetsGoRaises(aRuler), где aRuler передается как параметр по ссылке (см. выше); ChangeAltitude(theIncrease), где theIncrease – приращение изменения;

 

 

рис. 2. «Диаграмма и видимость объектов на стадии анализа»

  •  объект aLens класса TLens является полем объекта aRuler, а также передается как параметр по ссылке для объекта aRay; изменяет «направление» объекта aRay;
  •  объект aRay класса TRay является локальным параметром объекта aLightSource, т.е. создается и удаляется в процессе выполнения операции LetsGoRaises объекта theTable; посылает сообщение объекту aRuler о выборе другой линзы.

Эксплуатационные требования

  •  технические средства – ПЭВМ IBM PC;
  •  операционная система – MSDOS;
  •  процесс моделирования управляется одним оператором.

  1.  Проектирование программной системы

  1.  Идентификация классов и объектов

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

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

Проектируемая система должна обеспечивать отображение моделируемых объектов в виде графических фигур на экране дисплея. Каждый объект привязывается к определенной точке экрана. Поэтому введем класс «точка» (TPoint) и класс «фигура» (TFigure), последний обобщает графические свойства всех графических объектов.

  1.  Идентификация содержания классов

На этом шаге рассмотрим все классы, полученные в процессе выполнения анализа и синтеза.

Класс TPoint. Положение точки определяется координатами (X, Y), которые являются атрибутами. Z в качестве атрибута луча такой системы не требуется, т.к. она изображается в плоскости. Строго говоря, реальные объекты и их графические образы имеют разные линейные размеры и системы координат, однако будем считать, что размеры объектов даны в единицах измерения экрана дисплея (pixel-ах).

Класс TFigure. Графические объекты в целом характеризуются своим положением на экране и основным цветом, поэтому атрибутами класса TFigure является точка положения геометрического центра (theCenter) и цвет (theColor). Графический объект при создании должен сразу располагаться в каком-то месте, поэтому для него требуется соответствующий конструктор. При моделировании передвижения фигур требуется убирать их изображения и перерисовывать, поэтому введем соответствующие методы Hide и Show. Для управления фигурами необходимо ввести операции определения местоположения (GetCenter) и его изменения (SetCenter). Для удобства рисования введем также методы (GetColor)  и (SetColor).

Класс TEvent. Событие характеризуется некоторым значением, по которому одно событие отличается от другого. Для хранения такого события введем атрибут What, доступ к которому будет осуществляться методами (SetWhat) и (GetWhat).

Класс TRuler. Среди атрибутов этого класса имеются объекты, то есть это – агрегат из объектов: линз Lens. Т.к. заданием является «…изображение пути лучей, проходящих через линзы…», то для этого класса надо ввести замещающий метод Show, чтобы восстанавливать изображения линз после прохождения через них лучей (т.е. предусмотрим случай, когда луч пройдет через линзу и «испортит» ее изображение). Введем, также, метод PasteLens(), обслуживающий установку линз на линейку так, чтобы между ними было некоторое расстояние, задаваемое шириной линзы.

Класс TLens. В качестве атрибута должен содержать расстояние от начала линейки (theDistance). Для этого класса также надо ввести замещающий метод (Show).

Классы TCollectiveLens и TDispersiveLens полностью наследуют атрибуты TLens, но по-разному изображаются и “отклоняют луч света”. Поэтому для этих классов введем замещающие правила Show и DivergeRay.

 

  

 рис. 3. «Диаграмма классов на стадии проектирования»

Класс TTable. Атрибутами этого класса являются содержащиеся в нем («на нем» – стол все-таки) объекты, то есть это также агрегат из различных объектов: совокупность оптической скамьи Ruler, источника света. Внешние события должны восприниматься объектом класса TTable, поэтому необходимо ввести соответствующий метод HandleEvent. Он должен содержать поле theObject, определяющее номер п/п выбранного объекта для корректной обработки сообщений, а конкретно – передача фокуса объектам по порядку их следования.

Класс TReality. Объект этого класса содержит в себе сам бильярдный стол theTable.

  1.  Идентификация связей между классами и объектами

Класс TLens. Объект этого должен содержать операции доступа и изменения атрибута theDistance, соответственно, GetDistance, SetDistance; а также операцию изменения атрибута theLocation, соответственно ChangeLocation() и получения этого атрибута GetLocation(). Также для этого класса переопределяется метод Show.

 

 

 

рис. 4. «Диаграмма и видимость объектов на стадии проектирования»

Класс TRay. Объект этого класса взаимодействует с линзами, линейкой. При взаимодействии изменяются атрибуты, поэтому вводим операции доступа и изменения атрибута theDirection, соответственно, GetDirection, SetDirection. Также для этого класса переопределяется метод Show.

  1.  Реализация классов и объектов

Все разработанные классы и выявленные объекты будут включены в проект. Уточненные диаграммы классов и объектов и видимость объектов показаны на (рис. 3,4). На данном этапе переопределяем видимость объектов для большей компактности программы. Для диаграммы объектов составлена диаграмма взаимодействия (рис. 5), иллюстрирующая порядок взаимодействия луча с другими объектами. Следует обратить внимание, что диаграмма во многом представлена условно, т.к. из-за необходимости проверять диапазоны используемых данных, я буду вынужден использовать представленные операции большее число раз, при этом порядок их использования будет незначительно изменен (в случае особых ситуаций, которые, например, не могут быть использованы в основном итерационном алгоритме). В то же время рис. 5 более точно представляет алгоритм «преломления луча», чем рис. 4. Особые ситуации представлены в рис.6, где условные переходы из состояний в состояния описывают работу всего

 

  1.  

рис. 5. «Диаграмма взаимодействия на стадии проектирования»

рис. 6. «Диаграмма модулей системы»

алгоритма преломления, как например, отсутствие линз (см. рис. 6).

Относительно универсальные классы TPoint и TFigure, могут быть использованы в любой графической программной системе. Они составят модуль Figures. (рис. 6.)

Оставшиеся классы относятся к изучаемой области и будут входить в модуль Optic. Кроме того, для графического изображения простейших фигур необходимо использовать модуль Graphics. Головная программа main в данном случае является единственной и содержит инициализацию, выполнение и уничтожение единственного объекта класса TReality. Вся программная система реализуется одним процессом, поэтому нет необходимости составлять диаграмму процессов.

  1.  ПРОГРАММИРОВАНИЕ

На данном этапе были введены следующие константы для управления средой:

  1.  Константы предметной области

сDispLensNumber2 – задает количество рассеивающих линз

сСolLensNumber1 - задает количество собирающих линз

cRaiesNumber3 – задает количество лучей, испускаемых источником света

cFocuses[]4 – открытый массив, содержащий фокусные расстояния линз,

cRulerHeight - высота линейки в пикселях

cRulerLTCorner5 – координаты угла линейки

cAxisFromRuler6 - высота центральной оси над линейкой, относительно которой центрируются линзы и источник света

cLampRadius - радиус источника света (лампочки) в пикселях

cWidthLens7 - ширина линзы в пикселях (в работе линзы имеют одинаковую толщину, не зависящую от фокусного расстояния)

cShowRealTime – флаг «показывать лучи во время передвижения линз»

cShowImaginaryRaies – флаг «показывать мнимые лучи»

  1.  Константы событий

EvNothingничего не происходит

EvInitiate – инициация системы

EvCngObject – попытка передать фокус другому объекту

EvStart – запуск системы на моделирование изображения

EvPressUp – нажата кнопка «вверх»

EvPressDown – нажата кнопка «вниз»

EvPressLeft – нажата кнопка «влево»

EvPressRight – нажата кнопка «вправо»

EvQuit – нажата кнопка «выход»

  1.  Константы расположения линз

llRuler – линза находится на линейке и готова к «пропусканию» лучей

llSelf – линза находится на полке

  1.  Константы цветов

colRuler цвет линейки (YELLOW)

colLightSource – цвет лампочки (LIGHTRED)

colAxis  - цвет центральной оси (DARKGRAY)

colLens – цвет линзы (CYAN)

colRay – цвет луча света (MAGENTA)

colFocus – цвет активного предмета (WHITE)

Текст программы приведен в Приложении 1.



  1.  ТЕСТИРОВАНИЕ

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

Спецификация тестируемого метода:

  •  Имя: TCollectiveLens::DivergeRay;
  •  Назначение: выдать новое направление искаженного луча;
  •  Аргумент: TRay *aRay (указатель на искажаемый луч)
  •  Квалификация: реализация;
  •  Расширение: добавление;
  •  Действия: определение фокуса искажения луча, относительно которого далее строится новое направление луча. Это новое направление задается точкой, куда должен далее попасть луч. Если она выходит за границы допустимой области8, то направление корректируется снова9.

Тесты допустимых границ входных данных и функциональных границ сведем в таблицу 1.

Введем обозначения для ветвлений:

A:(aRay->GetDirection().Y!=aRay->GetCenter().Y);

B:(FinishPoint.Y==aRay->GetDirection().Y);

Построим диаграмму управления (рис. 7) и, руководствуясь ею, составим матрицу учета ветвей.

Из матрицы учета ветвей видно, что предусмотренные тесты охватывают все ситуации (см. таблицы 1 и 2).

N

Входные данные

Выходные данные

1

Луч падает перпендикулярно плоскости линзы: 

This->theCenter=={250, 300};

this->theColor==CYAN;

this->theLocation==llRuler;

this ->theRadius==100;

this ->theNumber==0;

this ->theDistance==200;

this ->theFocus==50;

aRay->theCenter=={100, 250};

aRay->theColor==MAGENTA;

aRay->theDirection=={250, 250};

Луч пройдет через фокус линзы:

TCollectiveLens::DivergeLens=={400, 400}

2

Луч проходит через оптический центр линзы:

This->theCenter=={250, 300};

this->theColor==CYAN;

this->theLocation==llRuler;

this ->theRadius==100;

this ->theNumber==0;

this ->theDistance==200;

this ->theFocus==50;

aRay->theCenter=={100, 250};

aRay->theColor==MAGENTA;

aRay->theDirection=={250, 300};

Направление не изменяется:

TCollectiveLens::DivergeLens=={550, 400}

3

Луч проходит через оптический центр линзы перпендикулярно ее плоскости:

This->theCenter=={250, 300};

this->theColor==CYAN;

this->theLocation==llRuler;

this ->theRadius==100;

this ->theNumber==0;

this ->theDistance==200;

this ->theFocus==50;

aRay->theCenter=={100, 300};

aRay->theColor==MAGENTA;

aRay->theDirection=={250, 300};

Луч продолжается по оси системы:

TcollectiveLens::DivergeLens=={getmaxx(), 300}

Таблица. 1. “Таблица тестирования”



Условия

1

2

3

A

(aRay->GetDirection().Y!=aRay->GetCenter().Y)

«да»

a

«нет»

a

a

B

(FinishPoint.Y==aRay->GetDirection().Y)

«да»

a

«нет»

a

a

Таблица. 2. “Матрица учета ветвей”

  1.  ЗАКЛЮЧЕНИЕ

Система может быть усовершенствована различными путями, а именно: изменение количества линз, характеристик некоторых объектов.

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

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

  1.  
    ПРИЛОЖЕНИЕ 1

Текст программы учебного примера «прибор для исследования оптических приборов».

  1.  //Figures.h - Интерфейс модуля графических фигур

#ifndef figures_h

#define figures_h

#include <math.h>



// Класс точка на экране

class TPoint

{

public:

 float X; // ордината

 float Y; // абсцисса

}; // TPoint



// Базовый класс фигура

class TFigure

{

private:

 TPoint theCenter;   // геометрический центр фигуры

 int theColor;   // основной цвет фигуры

public:

 TFigure(TPoint &aPoint, int aColor);

  // инициализировать новыми координатами и цветом

 virtual void Show(void) = 0;  // нарисовать

 void Hide(void);   // спрятать

 TPoint GetCenter(void); // дать координатч центра

 int GetColor(void)  // дать основной цвет фигуры

  { return (theColor);};

 void SetColor(int aColor);    // изменить цвет фигуры - передача фокуса

 void SetCenter(int aClear, TPoint aPoint);

   // установить новые координаты центра

}; // TFigure



#endif

  1.  // Figures.cpp - Реализация модуля графических фигур

#include "figures.h"

#include <graphics.h>



TFigure::TFigure(TPoint &aPoint, int aColor)

// инициализировать новыми координатами и цветом

{

theCenter = aPoint;

theColor = aColor;

};



void TFigure::Hide(void)

{

int ReservedColor = theColor;

theColor = BLACK;  // установить цвет фона

Show();   // отобразить цветом фона

theColor = ReservedColor; // восстановить цвет

}; // TFigure::Hide



TPoint TFigure::GetCenter(void) // возвратить координаты центра

{ return theCenter;};



void TFigure::SetColor(int aColor)// изменить цвет фигуры

{

theColor=aColor;

Show();

}; // TFigure::SetColor



void TFigure::SetCenter(int aClear, TPoint aPoint)

   // установить новые координаты центра

{

switch (aClear)

{

 case 0: theCenter = aPoint; Show(); break;

 case 1: Рide(); theCenter = aPoint; Show(); break;

 case 2: heCenter = aPoint;        break;

};

}; // TFigure::SetCenter

  1.  // Optic.h - Заголовок модуля элементов оптической системы

#ifndef optic_h

#define optic_h

#include "figures.h"

#include <graphics.h>



// Константы предметной области

const cDispLensNumber = 2; // количество рассеивающих линз

const cColLensNumber = 2; // количество собирающих линз

const cRaiesNumber = 9;  // количество личей, испускаемых источником света

const cFocuses[] = {30, 40, 50, 60};

const cRulerHeight = 40; // высота линейки

TPoint const cRulerLTCorner = {30,160}; // граничные коорд. угла линейки

const cAxisFromRuler = 50; // высота центральной оси над линейкой

const cLampRadius = 4;  // радиус лампочки источника света

const cWidthLens = 10;  // ширина линзы

const cHeightLightDest = 100; // высота экрана-приемника света

const cShowRealTime = 1;  // показывать лучи во время передвижения линз

const cShowImaginaryRaies = 1;  // показывать мнимые лучи





// Константы событий

enum TEvConstant {EvNothing, EvInitiate, EvCngObject, EvStart, EvPressUp,

   EvPressDown, EvPressLeft, EvPressRight, EvQuit};



// Константы расположения линз

enum TLocation {llRuler, llSelf};



// Константы цветов

const colRuler = YELLOW;

const colLightSource = LIGHTRED;

const colAxis = DARKGRAY;

const colLens = CYAN;

const colRay = MAGENTA;

const colFocus = WHITE;





//Интерфейсы классов

class TEvent

// класс "событие"

{

private:

 TEvConstant What;

public:

 void SetWhat(TEvConstant aWhat)

  { What = aWhat;};

 TEvConstant GetWhat(void)

  { return (What);};

}; // TEvent



class TRay: public TFigure

// класс "луч света"

{

private:

 TPoint theDirection; // направление луча

public:

 TRay(TPoint aDirection, TPoint aCenter, int aColor);

 virtual void Show(void);

 void SetDirection(TPoint aDirection)

  { theDirection = aDirection;};

 TPoint GetDirection(void)

  { return (theDirection);};

}; // TRay



class TLens: public TFigure

// класс линза - базовый для классов TDispersiveLens & TCollectiveLens

{

protected:

 TLocation theLocation;// нахождение линзы (на линейке, на полке)

 int theNumber; // номер линзы на полке

 int theRadius; // радиус линзы как окружности

 int theDistance; // расстояние линзы от начала линейки

 int theFocus;

public:

 TLens(int aFocus, int aDistance, int aNumber, TPoint aCenter, int aColor, int aRadius);

 virtual void Show(void) = 0;

 void SetDistance(int aDistance) { theDistance=aDistance;};

 int GetDistance(void)      { return (theDistance);};

 void ChangeLocation(void)       { Hide(); theLocation=(theLocation==llSelf)?llRuler:llSelf;};

 TLocation GetLocation(void)     { return (theLocation);};

 virtual TPoint DivergeRay(TRay *aRay) = 0; // отклонить луч

};  // TLens



class TDispersiveLens: public TLens

// класс "рассеивающая линза"

{

private:

 int theImaginary; // показывать мнимые лучи

public:

 TDispersiveLens(int aFocus, int aDistance, int aNumber, TPoint aCenter,

   int aColor, int aRadius, int anImaginary);

 virtual void Show(void);

 virtual TPoint DivergeRay(TRay *aRay);

}; // TDispersiveLens



class TCollectiveLens: public TLens

// класс "собирающая линза"

{

public:

 TCollectiveLens(int aFocus, int aDistance, int aNumber, TPoint aCenter, int aColor, int aRadius):

  TLens(aFocus, aDistance, aNumber, aCenter, aColor, aRadius) {};

 virtual void Show(void);

 virtual TPoint DivergeRay(TRay *aRay);

}; // TCollectiveLens



class TRuler: public TFigure

// класс "оптическая скамья"

{

private:

 TLens *PLens[cDispLensNumber+cColLensNumber];

 int theLength;

 TLens *aLens;

public:

 TRuler(TPoint anUpperLeftCorner, int aColor);

 virtual void Show(void);

 TLens *ChooseLens(int aNumber){ return (PLens[aNumber]);};

 TLens *ChooseLens(void)  { return (aLens);};// возвращает текущую линзу

 int GetNearDistance(int Skip);  // возвращает ближающую линзу

 void PasteLens(int theIncrease, int theNumber);

 int GetLength(void)  { return (theLength);};

 ~TRuler(void);

}; // TRuler



class TLightSource: public TFigure

// класс "источник света"

{

private:

 TRay *PRay;

 int theAltitude;

 int theRaiesNumber;

public:

 TLightSource(TPoint aCenter, int aColor, int aRaiesNumber);

 virtual void Show(void);

 void LetsGoRaies(TRuler *aRuler);

 void ChangeAltitude(int theIncrease);

}; // TLigthSource



class TTable

// класс "оптический стол"

{

private:

 TRuler *PTheRuler;

 TLightSource *PLightSource;

 int theObject;

 void Initiate(void); // начальная расстановка "вещей на столе"

public:

 TTable(void);

 void HandleEvent(TEvent *anEvent); //обработка событий

 void Start(void); // начало моделирования нового изображения

 ~TTable(void);

}; // TTable



class TReality

// класс "моделируемая действительность"

{

private:

 TTable *PTheTable; // указатель на оптический стол

public:

 TReality(void);

 void Run(void);

 ~TReality(void);

}; // TReality





#endif

  1.  // Optic.cpp - Реализация модуля элементов оптической системы

#include "figures.h"

#include "optic.h"

#include <graphics.h>

#include <stdlib.h>

#include <stdio.h>

#include <conio.h>

#include <string.h>



#include <dos.h>

#include <time.h>





// Реализация класса "луч света"

TRay::TRay(TPoint aDirection, TPoint aCenter, int aColor):

     TFigure(aCenter, aColor)

{

theDirection = aDirection;

}; // TRay::TRay



void TRay::Show(void)

{

setcolor(GetColor());

line(GetCenter().X, GetCenter().Y, theDirection.X, theDirection.Y);

}; //TRay::Show





// Реализация класса "линза"

TLens::TLens(int aFocus, int aDistance, int aNumber, TPoint aCenter, int aColor, int aRadius):

     TFigure(aCenter, aColor)

{

theFocus = aFocus;

theNumber = aNumber;

theLocation = llSelf;

theRadius = aRadius;

SetDistance(aDistance);

}; // TLens::TLens





// Реализация класса "рассеивающая линза"

TDispersiveLens::TDispersiveLens (int aFocus, int aDistance, int aNumber,

TPoint aCenter, int aColor, int aRadius, int anImaginary):

TLens(aFocus, aDistance, aNumber, aCenter, aColor, aRadius)

{

theImaginary = anImaginary;

}; // TDispersiveLens::TDispersiveLens



void TDispersiveLens::Show(void)

{

TPoint aCenter=GetCenter();

if (theLocation == llSelf)

{

 aCenter.X = (20+cWidthLens)*theNumber;

 aCenter.Y = theRadius+10;

} // if

else

{

 char string[4];

 setcolor(BLACK);

 outtextxy((20+cWidthLens)*theNumber-cWidthLens, theRadius+10, "---");

 setcolor(GetColor());

 outtextxy((20+cWidthLens)*theNumber-cWidthLens, theRadius+10, itoa(theDistance, string, 10));

}; // else

setcolor(GetColor());

ellipse(aCenter.X+cWidthLens/2, aCenter.Y, 90, 270, cWidthLens/2-1, theRadius);

ellipse(aCenter.X-cWidthLens/2, aCenter.Y, 270, 90, cWidthLens/2-1, theRadius);

line(aCenter.X+cWidthLens/2-1, aCenter.Y-theRadius,

 aCenter.X-cWidthLens/2+1, aCenter.Y-theRadius);

line(aCenter.X+cWidthLens/2-1, aCenter.Y+theRadius,

 aCenter.X-cWidthLens/2+1, aCenter.Y+theRadius);

}; // TDispersiveLens:Show



TPoint TDispersiveLens::DivergeRay(TRay *aRay)

{

// определяем точку пересечения вспомогательного луча с искаженным

TPoint FinishPoint=GetCenter();

FinishPoint.X-=theFocus; // фокус неравен нулю

FinishPoint.Y-=theFocus*(aRay->GetDirection().Y-aRay->GetCenter().Y)

/(aRay->GetDirection().X-aRay->GetCenter().X);

  /*луч не может иметь одну и ту-же точку начала и конца, т.е

    "сжаться в точку", т.к. между линзами есть расстояние*/

// покажем мнимые лучи

if (theImaginary)

{

 setcolor(aRay->GetColor());

 setlinestyle(DOTTED_LINE, 1, 1);

 line(FinishPoint.X, FinishPoint.Y, aRay->GetDirection().X, aRay->GetDirection().Y);

 setlinestyle(SOLID_LINE, 1, 1);

}; // if

// продолжим полученую прямую до "стенок оптической трубы"

TPoint BoundaryPoint=aRay->GetDirection();

BoundaryPoint.Y=GetCenter().Y+((FinishPoint.Y<BoundaryPoint.Y)?theRadius:-theRadius);

if (aRay->GetDirection().Y!=BoundaryPoint.Y)

 // в противном случае луч уходит за "стенки оптической трубы"

 if (FinishPoint.Y==aRay->GetDirection().Y)

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

 {

  BoundaryPoint.Y=aRay->GetDirection().Y;

  BoundaryPoint.X=getmaxx();

 } // if

 else

 // здесь эта высота влияет на изменение основания треугольника после линзы

  BoundaryPoint.X+=(aRay->GetDirection().Y-BoundaryPoint.Y)*

(GetCenter().X-FinishPoint.X)/(FinishPoint.Y-aRay->GetDirection().Y);

return BoundaryPoint;

}; // TDispersiveLens::DivergeRay





// Реализация класса "собирающая линза"

void TCollectiveLens::Show(void)

{

TPoint aCenter=GetCenter();

if (theLocation == llSelf)

{

 aCenter.X = (20+cWidthLens)*theNumber;

 aCenter.Y = theRadius+10;

} // if

else

{

 char string[4];

 setcolor(BLACK);

 outtextxy((20+cWidthLens)*theNumber-cWidthLens, theRadius+10, "---");

 setcolor(GetColor());

 outtextxy((20+cWidthLens)*theNumber-cWidthLens, theRadius+10, itoa(theDistance, string, 10));

}; // else

setcolor(GetColor());

ellipse(aCenter.X, aCenter.Y, 270, 90, cWidthLens/2, theRadius);

ellipse(aCenter.X, aCenter.Y, 90, 270, cWidthLens/2, theRadius);

}; // TCollectiveLens:Show



TPoint TCollectiveLens::DivergeRay(TRay *aRay)

{

// определяем точку пересечения вспомогательного луча с искаженным

TPoint FinishPoint = GetCenter();

FinishPoint.X+=theFocus; // фокус неравен нулю

if (aRay->GetDirection().Y!=aRay->GetCenter().Y)

 // если луч падает перпендикулярно плоскости лифта, то он попадает в фокус линзы

 FinishPoint.Y+=(aRay->GetDirection().Y-aRay->GetCenter().Y)*

theFocus/(GetCenter().X-aRay->GetCenter().X);

  /*луч не может иметь одну и ту-же точку начала и конца, т.е

    "сжаться в точку", т.к. между линзами есть расстояние*/

// продолжим полученую прямую до "стенок оптической трубы"

TPoint BoundaryPoint=aRay->GetDirection();

if (FinishPoint.Y==aRay->GetDirection().Y)

 // в этом случае высота маленького треугольника слишком мала

  BoundaryPoint.X=getmaxx();

 else

 // здесь эта высота влияет на изменение основания большого треугольника

 {

  BoundaryPoint.Y=GetCenter().Y+((FinishPoint.Y<BoundaryPoint.Y)?-theRadius:theRadius);

  BoundaryPoint.X+=(FinishPoint.X-aRay->GetDirection().X)*

(BoundaryPoint.Y-aRay->GetDirection().Y)/(FinishPoint.Y-aRay->GetDirection().Y);

 }; // else

// высота большого треугольника неравна нулю, т.к. луч направляется к другой "стенке трубы"

return BoundaryPoint;

}; // TCollectiveLens::DivergeRay





// Реализация класса "оптическая скамья"

TRuler::TRuler(TPoint aLeftUpperCorner, int aColor):

   TFigure(aLeftUpperCorner, aColor)

{

aLens = NULL;

theLength = 2 * (getmaxx()/2-aLeftUpperCorner.X);

TPoint aCenter = aLeftUpperCorner;

aCenter.X = getmaxx()/2;

aCenter.Y-=cAxisFromRuler;

int aDistance=aCenter.X-GetCenter().X;

int Counter;

for (Counter=0; Counter<=cDispLensNumber-1; ++Counter)

 PLens[Counter] = new TDispersiveLens(cFocuses[Counter], aDistance, Counter+1, aCenter,

          colLens, cAxisFromRuler, cShowImaginaryRaies);

for (Counter=0; Counter<=cColLensNumber-1; ++Counter)

 PLens[Counter+cDispLensNumber] = new TCollectiveLens

  (cFocuses[Counter], aDistance, Counter+cDispLensNumber+1, aCenter, colLens, cAxisFromRuler);

}; // TRuler::TRuler



void TRuler::Show(void)

{

TPoint RightDownCorner = GetCenter(); // нижний правый угол линейки

// определим координаты углов

RightDownCorner.X+=theLength;

RightDownCorner.Y+=cRulerHeight;

// нарисовать линейку

setfillstyle(SOLID_FILL, GetColor());

bar(GetCenter().X, GetCenter().Y+1, RightDownCorner.X, RightDownCorner.Y);

// наметить риски

float Counter = GetCenter().X+1;

setcolor(BLACK);

while (Counter < RightDownCorner.X)

{

 line(Counter, GetCenter().Y, Counter,

  GetCenter().Y+1+cRulerHeight/(fmod(Counter+1-GetCenter().X, 20) ?

  (fmod(Counter+1-GetCenter().X, 10) ? 4:2.5):2));

 Counter+=2;

}; // while

outtextxy(GetCenter().X+4, RightDownCorner.Y-10, "KUK' Optic");

// нарисовать центральную ось

setcolor(colAxis);

line(GetCenter().X, PLens[0]->GetCenter().Y, RightDownCorner.X, PLens[0]->GetCenter().Y);

// нарисовать линзы

for (Counter=0; Counter<=cDispLensNumber+cColLensNumber-1; ++Counter)

 PLens[Counter]->Show();

}; // TRuler::Show



int TRuler::GetNearDistance(int Skip)

{

int lSkip = theLength;

for (int Counter=0; Counter<cDispLensNumber+cColLensNumber; ++Counter)

 if ((PLens[Counter]->GetLocation()==llRuler) &&

     (Skip<PLens[Counter]->GetDistance()) && (lSkip>PLens[Counter]->GetDistance()))

 {

  aLens=PLens[Counter];

  lSkip=aLens->GetDistance();

 }; // if

return lSkip;

}; // TRuler::GetNearDistance



void TRuler::PasteLens(int theIncrease, int theNumber)

{

TPoint aCenter=PLens[theNumber]->GetCenter();

if (PLens[theNumber]->GetLocation()==llRuler)

{

 if (theIncrease) aCenter.X+=theIncrease;

 int Counter;

 for (Counter=0; Counter<cDispLensNumber+cColLensNumber; ++Counter)

 {

  int aDistance=abs(aCenter.X-ChooseLens(Counter)->GetCenter().X);

  if ((Counter!=theNumber) && (aDistance<=cWidthLens+1) &&

   (ChooseLens(Counter)->GetLocation()==llRuler))

  {

   if (theIncrease)

    aCenter.X+=(theIncrease*(aDistance+cWidthLens+2))/abs(theIncrease);

   else

    aCenter.X-=aDistance+cWidthLens+2;

   Counter=-1;

   continue;

  }; // if

 }; // for

}; // if

int aDistance=ChooseLens(theNumber)->GetDistance()-

 ChooseLens(theNumber)->GetCenter().X+aCenter.X;

if ((aDistance>cLampRadius+cWidthLens/2) &&

    (aDistance<theLength-cWidthLens/2))

{

 ChooseLens(theNumber)->SetDistance(aDistance);

 ChooseLens(theNumber)->SetCenter(abs(theIncrease), aCenter);

}; // if

}; // TRuler::PasteLens



TRuler::~TRuler(void)

{

delete []PLens;

delete []PLens;

}; // TRuler::~TRuler





// Реализация класса "источник света"

TLightSource::TLightSource(TPoint aCenter, int aColor, int aRaiesNumber):

    TFigure(aCenter, aColor)

{

theAltitude = 0;

theRaiesNumber = aRaiesNumber;

}; // TLigthSource::TLigtSource



void TLightSource::Show(void)

{

// нарисовать плафон лампочки

char string[4];

setcolor(BLACK);

outtextxy(GetCenter().X-40, GetCenter().Y-4, "----");

setcolor(GetColor());

circle(GetCenter().X, GetCenter().Y, cLampRadius);

setfillstyle(SOLID_FILL, GetColor());

floodfill(GetCenter().X, GetCenter().Y, GetColor());

outtextxy(GetCenter().X-40, GetCenter().Y-4, itoa(theAltitude, string, 10));

}; // TLigthSource::Show



void TLightSource::LetsGoRaies(TRuler *aRuler)

{

// вычисляем расстояние до ближайшей линзы (если нет, то до приемника)

cleardevice();

aRuler->Show();

Show();

for (float Counter=-1; (theRaiesNumber>1) && (Counter<=1); Counter+=(float)2/(theRaiesNumber-1))

{

 int Skip=0;

 int nxtSkip;

 // пускаем лучики

 TPoint aDirection = GetCenter(), newDirection;

 aDirection.X+=aRuler->GetNearDistance(Skip);

 aDirection.Y=aRuler->ChooseLens(0)->GetCenter().Y+Counter*cAxisFromRuler;

 PRay = new TRay(aDirection, GetCenter(), colRay);

 PRay->Show();



 do

 {

  Skip=aRuler->GetNearDistance(Skip);

  if (Skip==aRuler->GetLength()) break;

  if (Skip<(aRuler->GetCenter().X+aRuler->GetLength()))

   newDirection = aRuler->ChooseLens()->DivergeRay(PRay);



  nxtSkip=GetCenter().X+aRuler->GetNearDistance(Skip);

  if (newDirection.X>nxtSkip)

  {

   newDirection.Y=PRay->GetDirection().Y+(newDirection.Y-PRay->GetDirection().Y)*

    (nxtSkip-PRay->GetDirection().X)/(newDirection.X-PRay->GetDirection().X);

   newDirection.X=nxtSkip;

  }; // if



  PRay->SetCenter(2, PRay->GetDirection());

  PRay->SetDirection(newDirection);

  PRay->Show();

 } while (newDirection.X==nxtSkip);



 delete PRay;

}; // for

}; // TLightSource::LetsGoRaies



void TLightSource::ChangeAltitude(int theIncrease)

{

// увеличиваем (уменьшаем) высоту источника света над центральной осью

if ((theIncrease>0) && (theAltitude<cAxisFromRuler) ||

    (theIncrease<0) && (1-theAltitude<cAxisFromRuler))

{

 theAltitude+=theIncrease;

 TPoint aCenter = GetCenter();

 aCenter.Y-=theIncrease;

// спрятать и показать объект, уже с новыми координатами

 SetCenter(1, aCenter);

}; // if

}; // TLightSource::ChangeAltitude





// Реализация класса "оптический стол"

TTable::TTable(void)

{

theObject = 0; // активный объект - источник света

// создать линейку

TPoint aCorner = cRulerLTCorner;

if (aCorner.Y < 2*getmaxy()/3)

 aCorner.Y = 2*getmaxy()/3;

aCorner.X+=40;

PTheRuler = new TRuler(aCorner, colRuler);

// создать источник света

aCorner.Y-=cAxisFromRuler;

PLightSource = new TLightSource(aCorner, colFocus, cRaiesNumber);



Initiate(); // осуществить начальную расстановку "вещей на столе"

}; // TTable::TTable



void TTable::Initiate(void)

{

PTheRuler->Show();

PLightSource->Show();

}; // TTable::Initiate



void TTable::HandleEvent(TEvent *anEvent)

{

switch (anEvent->GetWhat())

{

 case EvInitiate: Initiate(); break;

 case EvPressLeft:

if (PTheRuler->ChooseLens(theObject-1)->GetLocation()==llRuler)

 if (theObject!=0) PTheRuler->PasteLens(-1, theObject-1); break;

 case EvPressRight: if (theObject!=0)

if (PTheRuler->ChooseLens(theObject-1)->GetLocation()==llRuler)

 if (theObject!=0) PTheRuler->PasteLens(1, theObject-1); break;

 case EvPressUp:

if (theObject==0) PLightSource->ChangeAltitude(1);

else

{

 PTheRuler->ChooseLens(theObject-1)->ChangeLocation();

 PTheRuler->PasteLens(0, theObject-1);

}; // else

break;

 case EvPressDown:

if (theObject==0) PLightSource->ChangeAltitude(-1);

else

{

 PTheRuler->ChooseLens(theObject-1)->ChangeLocation();

 PTheRuler->PasteLens(0, theObject-1);

}; // else

break;

 case EvCngObject:

if (theObject!=cDispLensNumber+cColLensNumber)

{

 if (theObject==0) PLightSource->SetColor(colLightSource);

 else PTheRuler->ChooseLens(theObject-1)->SetColor(colLens);

 PTheRuler->ChooseLens(theObject++)->SetColor(colFocus);

} // if

else

{

 PTheRuler->ChooseLens(theObject-1)->SetColor(colLens);

 theObject=0; // лампочка

 PLightSource->SetColor(colFocus);

}; // else

break;

}; // switch





if (cShowRealTime && (anEvent->GetWhat()>2) && (anEvent->GetWhat()<8))

 Start();

}; // TTable::HandleEvent



void TTable::Start(void)

{

// пустить лучи

PLightSource->LetsGoRaies(PTheRuler);

}; // TTable::Start



TTable::~TTable(void)

{

delete PTheRuler;

delete PLightSource;

}; // TTable::~TTable





// Реализация класса "моделируемая действительность"

TReality::TReality(void)

{

// установка графического режима

// требуется автораспознавание

int gdriver = DETECT, gmode, errorcode;

// инициализация графики и локальных переменных

initgraph(&gdriver, &gmode, "");

// чтение результата инициальзации

errorcode = graphresult();

if (errorcode != grOk)  /* произошла ошибка */

{

 printf("Ошибка инициализации графики: %s\n", grapherrormsg(errorcode));

 printf("Нажмите какую-нибудь клавишу... ");

 getch();

 exit(1); /* уничтожение с кодовой ошибкой */

}; //if



// создать экземпляр Оптической системы

PTheTable = new TTable;

}; // TReality::TReality



void TReality::Run(void)

{

TEvent theEvent;  // создать экземпдяр объекта "событие"

theEvent.SetWhat(EvNothing); // еще ничего не произошло



// цикл получения и генерации событий

do

{

// событие от клавиатуры

 theEvent.SetWhat(EvNothing);

 if (kbhit())

 {

  char ch = getch();

  strupr(&ch);

  switch(ch)

  {

   case 'S': theEvent.SetWhat(EvStart); break;

   case 'Q': theEvent.SetWhat(EvQuit); break;

   case 'H': theEvent.SetWhat(EvPressUp); break;

   case 'K': theEvent.SetWhat(EvPressLeft); break;

   case 'M': theEvent.SetWhat(EvPressRight); break;

   case 'P': theEvent.SetWhat(EvPressDown); break;

   case '\t': theEvent.SetWhat(EvCngObject); break;

  }; // switch

  ch = ' ';

 }; // if

// переслать сообщение о событии возможному получателю

PTheTable->HandleEvent

// и, может быть, получить от него

(&theEvent);

} while (theEvent.GetWhat() != EvQuit); //do

}; // TReality::Run



TReality::~TReality(void)

{

delete PTheTable; // убрать стол

closegraph();      // отменить графический режим

}; // TReality::~TReality

  1.  // main.cpp - головная программа системы "Оптика"

#include "optic.h"



int main(void)

{

TReality theReality; // инициализация всей системы

theReality.Run(); // начать имитацию процесса

return(0);

}; // main

  1.  ПРИЛОЖЕНИЕ 2

Текст программы драйвера.

  1.  // Проект "Оптика". Драйвер для тестирования подпрограммы.

#include "optic.h"

#include "figures.h"

#include <graphics.h>

#include <iostream.h>

#include <conio.h>

#include <stdlib.h>



void Tester(int Test, TLens *aLens, TRay *aRay, TPoint aResult)

{

TPoint Finish = aLens->DivergeRay(aRay);

if ((Finish.X==aResult.X) && (Finish.Y==aResult.Y))

 cout << "Тест N" << Test << " прошел успешно." << endl << " факт {"

      << Finish.X << ", " << Finish.Y

      << "}; ожидается {" << aResult.X << ", " << aResult.Y << "}." << endl;

else

 cout << "Тест N" << Test << " завершен ошибочно:" << endl << " факт {"

      << Finish.X << ", " << Finish.Y

      << "}; ожидается {" << aResult.X << ", " << aResult.Y << "}." << endl;

cout << endl;

};



void main(void)

{

// требуется автораспознавание

int gdriver = DETECT, gmode, errorcode;

// инициализация графики и локальных переменных

initgraph(&gdriver, &gmode, "");

// чтение результата инициальзации

errorcode = graphresult();

if (errorcode != grOk)  /* произошла ошибка */

{

 cout << "Ошибка инициализации графики: %s\n" << grapherrormsg(errorcode) << endl;

 cout << "Нажмите какую-нибудь клавишу... " << endl;

 getch();

 exit(1); /* уничтожение с кодовой ошибкой */

}; //if

int MaxX = getmaxx();

closegraph();       // отменить графический режим





// указатель на линзу, которая не изменяет своего положения (см. тестовые таблицы)

TCollectiveLens *Lens;

// и на лучи, параметры которых описаны в тех-же таблицах

TRay *Ray[3];



// ...и заданы здесь

int aFocus     =50;

int aDistance      =200;

int aNumber     =0;

TPoint aLensCenter ={250, 300};

int aLensColor     =CYAN;

int aRadius      =100;

int aRayColor     =MAGENTA;



// ожидаемые результаты

TPoint aRayCenter[] ={{100, 250}, {100, 250}, {100, 300}};

TPoint aDirection[] ={{250, 250}, {250, 300}, {250, 300}};

TPoint theResult[]  ={{400, 400}, {550, 400}, {MaxX, 300}};



Lens = new TCollectiveLens(aFocus, aDistance, aNumber, aLensCenter, aLensColor, aRadius);

Ray[0] = new TRay(aDirection[0], aRayCenter[0], aRayColor);

Ray[1] = new TRay(aDirection[1], aRayCenter[1], aRayColor);

Ray[2] = new TRay(aDirection[2], aRayCenter[2], aRayColor);



// проводим тесты 1..3 по очеред

Tester(1, Lens, Ray[0], theResult[0]);

Tester(2, Lens, Ray[1], theResult[1]);

Tester(3, Lens, Ray[2], theResult[2]);



delete []Ray;

delete Lens;

}; // main

  1.  ПРИЛОЖЕНИЕ 3

  1.   Листинг тестирования

Тест N1 прошел успешно.

факт {400, 400}; ожидается {400, 400}.

Тест N2 завершен ошибочно.

факт {550.000183, 400}; ожидается {550, 400}.

Тест N3 прошел успешно.

факт {639, 300}; ожидается {639, 300}.

  1.  СПИСОК ЛИТЕРАТУРЫ

  1.  И.Р. Дубов, В.А. Барков, А.Г. Долинин. «Технология программирования». -Методические указания к курсовой работе. Владимир, 1999. – 48 с.
  2.  Березин Б.И., Березин С.Б. «Начальный курс C и C++». – М.: Диалог-МИФИ, 1999. – 288 с.

1 Здесь и далее: «термин на полке» не обозначает, что существует дополнительный объект полка (нет соответствующего факта).

2 Неотрицательное число.

3 Количество лучей не менее двух.

4 Фокусы линз задаются числами большими нуля, соответственно сначала задаются фокусы рассеивающих линз, затем собирающих.

5 Одновременно этот параметр является и «центром» фигуры, т.е. поле TRuler.theCenter задается этой константой.

6 Отсчитывается от верхнего ребра линейки и является (упоминается) «главной оптической осью системы»

7 Параметр больше нуля, т.к. в методах DivergeRay предполагается толщина линз неравная нулю (деление на ноль).

8 В программе допустимая область упоминается как «стенки оптической трубы» (по аналогии и смыслу с подзорной трубой).

9 Все условия сведены к математике, которая выражается в виде вычисления координат методом пропорциональных треугольников.


 

А также другие работы, которые могут Вас заинтересовать

60724. Классификация программ растровой графики 2.42 MB
  Цель: дать учащимся понятие классификации программ растровой графики. И какие существуют виды компьютерной графики. Что такое векторная графика Назовите достоинства и недостатки векторной графики.
60725. Пример решения жизненной задачи 156.5 KB
  Это разнообразило бы отдых учащихся да и сами вы не прочь прокатится с горки. Итак у вас появляется жизненная задача построение ледяной горки. Основная часть Итак приступаем к построению ледяной горки.
60726. Проверка знаний по теме: «Microsoft Excel и моделирование в задачах управления» 377 KB
  Цель: проверка знаний учащихся по данному разделу Электронная таблица Microsoft Excel и моделирование в задачах управления. Закрепить на практике умения учащихся работать в электронной таблице Microsoft Excel.
60727. Моделирование биологической системы 1.27 MB
  Цель: дать понятие учащимся о моделирование биологической системы Задачи: сформировать у учащихся представления о моделировании биологической системы. актуализировать и углубить знания о моделях и моделировании.
60728. Пользовательский интерфейс графического редактора 339 KB
  Цель: дать учащимся понятие о пользовательском интерфейс графического редактора аdobe PhotoShop. Закрепить на практике умения учащихся использовать графический редактор аdobe PhotoShop.
60729. Сканирование изображений 3.05 MB
  Задачи: Актуализировать знания учащихся о компьютерной графике. Закрепить на практике умения учащихся использовать графический редактор Paint. Развивать творческое мышление через задания творческого характера.
60730. Форматы изображений растровой графики 182.5 KB
  Сохраните рисунок в другом формате воспользовавшись командой Файл Сохранить как в папке Эксперимент Имя файла: урок 1; Тип файла: 24-разрядный рисунок. Откройте первый рисунок Файл Открыть в папке Эксперимент Имя файла: урок 1...
60731. Компьютерная графика. Виды графических изображений 8.23 MB
  Цель: дать понятие компьютерной графике и видам графических изображений. Задачи: Актуализировать знания учащихся о компьютерной графике. Закрепить на практике умения учащихся различать виды графических изображений.
60732. Этапы решения задач с помощью компьютера 237 KB
  Построив модель задачи и исследовав ее можно найти оптимальное решение. 2 Этап: информационную модель процесса После постановки задачи построить информационную модель процесса выбора подарка а такая модель предполагает три составляющих...