Разработать программу для решения эллиптического уравнения,используя ускоренный метод Либмана

#endif // !defined(AFX_RESTR_H__E2B59A36_E933_4BEA_B0C3_5397CA84C16F__INCLUDED_)

Restr.cpp
// Restr.cpp : implementation file
//

#include "stdafx.h"
#include "libman.h"
#include "Restr.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// Restr dialog


Restr::Restr(CWnd* pParent /*=NULL*/)
: CDialog(Restr::IDD, pParent)
{
//{{AFX_DATA_INIT(Restr)
// NOTE: the ClassWizard will add member initialization here
//}}AFX_DATA_INIT
}


void Restr::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(Restr)
DDX_Control(pDX, IDC_EDIT4, m_Edit4);
DDX_Control(pDX, IDC_EDIT3, m_Edit3);
DDX_Control(pDX, IDC_EDIT2, m_Edit2);
DDX_Control(pDX, IDC_EDIT1, m_Edit1);
DDX_Control(pDX, IDC_COMBO1, m_Combo1);
//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(Restr, CDialog)
//{{AFX_MSG_MAP(Restr)
ON_CBN_SELENDOK(IDC_COMBO1, OnSelendokCombo1)
ON_EN_KILLFOCUS(IDC_EDIT1, OnKillfocusEdit1)
ON_EN_KILLFOCUS(IDC_EDIT2, OnKillfocusEdit2)
ON_EN_KILLFOCUS(IDC_EDIT3, OnKillfocusEdit3)
ON_EN_KILLFOCUS(IDC_EDIT4, OnKillfocusEdit4)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// Restr message handlers

BOOL Restr::OnInitDialog()
{
CDialog::OnInitDialog();

// TODO: Add extra initialization here
m_Combo1.AddString(_T("сверху")); // инициализируем элементы управления значениями,
m_Combo1.AddString(_T("слева")); // заданными в вызывающей программе
m_Combo1.AddString(_T("снизу"));
m_Combo1.AddString(_T("справа"));
m_Combo1.SetCurSel(m_side);
m_Edit1.SetValidChar(_T("0123456789."));
sprintf(buf,"%g",m_B);
m_Edit1.SetWindowText(buf);
m_Edit2.SetValidChar(_T("0123456789.-"));
sprintf(buf,"%g",m_BV);
m_Edit2.SetWindowText(buf);
m_Edit3.SetValidChar(_T("0123456789."));
sprintf(buf,"%g",m_E);
m_Edit3.SetWindowText(buf);
m_Edit4.SetValidChar(_T("0123456789.-"));
sprintf(buf,"%g",m_EV);
m_Edit4.SetWindowText(buf);

return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}


void Restr::OnSelendokCombo1()
{
// TODO: Add your control notification handler code here
UpdateData();
m_side=m_Combo1.GetCurSel(); // считываем номер выбранного элемента
}

void Restr::OnKillfocusEdit1()
{
// TODO: Add your control notification handler code here
UpdateData();
m_Edit1.GetWindowText(buf,20); // считываем значение координаты начала участка
m_B=atof(buf);
sprintf(buf,"%g",m_B);
m_Edit1.SetWindowText(buf);
UpdateData(FALSE);
}

void Restr::OnKillfocusEdit2()
{
// TODO: Add your control notification handler code here
UpdateData();
m_Edit2.GetWindowText(buf,20); // считываем значение в начале участка
m_BV=atof(buf);
sprintf(buf,"%g",m_BV);
m_Edit2.SetWindowText(buf);
UpdateData(FALSE);
}

void Restr::OnKillfocusEdit3()
{
// TODO: Add your control notification handler code here
UpdateData();
m_Edit3.GetWindowText(buf,20); // считываем значение координаты конца участка
m_E=atof(buf);
sprintf(buf,"%g",m_E);
m_Edit3.SetWindowText(buf);
UpdateData(FALSE);
}

void Restr::OnKillfocusEdit4()
{
// TODO: Add your control notification handler code here
UpdateData();
m_Edit4.GetWindowText(buf,20); // считываем значение в конце участка
m_EV=atof(buf);
sprintf(buf,"%g",m_EV);
m_Edit4.SetWindowText(buf);
UpdateData(FALSE);
}

void Restr::OnOK()
{
// TODO: Add extra validation here
if(m_B < m_E && // координата начала должна быть меньше, чем координата конца
(m_E <= m_X && (m_side == 0 || m_side == 2) || // координата конца не более
// предельного значения,
m_E <= m_Y && (m_side == 1 || m_side == 3))) // соответствующего стороне
CDialog::OnOK();
else
MessageBox("Проверьте координаты","Внимание");
}

Card.h
#if !defined(AFX_CARD_H__F41A1061_D896_4DFD_A38E_B7379FB365C5__INCLUDED_)
#define AFX_CARD_H__F41A1061_D896_4DFD_A38E_B7379FB365C5__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Card.h : header file
//

/////////////////////////////////////////////////////////////////////////////
// CCard window

class CCard : public CWnd
{
public:
CCard();
void Create(CRect r,CWnd *pParent); // создать окно
void Reflect(double dimx,double dimy,double h,double *grid);// отобразить результат
virtual ~CCard();
CRect m_Rect; // прямоугольник окна
double m_dimx; // размерность объекта по X
double m_dimy; // размерность объекта по Y
double m_zoom; // масштаб отображения
int m_grp; // размер группы
int m_ext; // вид группы (0 - группа пикселов,
// 1 - группа узлов)
long m_nx; // размерность по X
long m_ny; // размерность по Y
double m_min; // минимальное значение узла
double m_grad; // уровень градуировки
double *m_grid; // массив узлов
int m_type; // тип отображения
// Generated message map functions
protected:
//{{AFX_MSG(CCard)
afx_msg void OnPaint();
afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_CARD_H__F41A1061_D896_4DFD_A38E_B7379FB365C5__INCLUDED_)

Card.cpp
// Card.cpp : implementation file
//

#include "stdafx.h"
#include "Card.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CCard

int istopaint(int *color,int type);

CCard::CCard()
{
}

CCard::~CCard()
{
}

void CCard::Create(CRect r, CWnd *pWin)
{
CWnd::Create(NULL,"",WS_CHILD|WS_VISIBLE,r,pWin,100000); // создаем окно
GetWindowRect(&m_Rect); // берем прямоугольник созданного окна
ScreenToClient(&m_Rect); // и переводим координаты в клиентские
m_type=-1; // объект не задан
}

// задание объекта
void CCard::Reflect(double dimx, double dimy, double h,double *grid)
{
m_dimy=dimy; // сохраняем метрическую размерность
m_dimx=dimx;
m_grid=grid; // сохраняем указатель на массив узлов
double zoomx=(m_Rect.Width()-10)/dimx;// вычисляем предварительные масштабы по осям
double zoomy=(m_Rect.Height()-10)/dimy;
m_zoom=zoomx > zoomy ? zoomy : zoomx; // и берем меньший из них
int pixx=(int)(m_dimx*m_zoom); // количество пикселов и количество узлов по осям
m_nx=(long)(m_dimx/h)+1;
int pixy=(int)(m_dimy*m_zoom);
m_ny=(long)(m_dimy/h)+1;
m_min=*grid; // ищем минимум и максимум в массиве узлов
double max=*grid;
for(int i=0,k=1; i < m_nx; i++)
for(int j=0; j < m_ny; j++){
if(*(grid+k) > max)
max=*(grid+k);
if(*(grid+k) < m_min)
m_min=*(grid+k);
k++;
}
m_grad=(max-m_min)/255.; // вычисляем уровень градуировки
if(pixx >= m_nx){ // если пикселов больше, чем узлов
m_grp=pixx/m_nx; // группа пикселов отображает один узел
// убираем пикселы, которые не войдут в группы
zoomx=(m_Rect.Width()-10-pixx%m_nx)/dimx;
zoomy=(m_Rect.Height()-10-pixy%m_ny)/dimy;
m_zoom=zoomx > zoomy ? zoomy : zoomx; // уточняем масштаб
m_ext=0; // выставляем признак
}
else{ // если узлов больше, чем пикселов
// один писел отображает группу узлов
m_grp=m_nx%pixx != 0 || m_ny%pixy != 0 ? m_nx/pixx+1 : m_nx/pixx;
// убираем пикселы, для которых не хватило узлов
zoomx=(m_Rect.Width()-10-(m_grp*pixx-m_nx)/m_grp)/dimx;
zoomy=(m_Rect.Height()-10-(m_grp*pixy-m_ny)/m_grp)/dimy;
m_zoom=zoomx > zoomy ? zoomy : zoomx; // уточныем масштаб
m_ext=1; // выставляем признак
}
m_type=0;
Invalidate();
}

BEGIN_MESSAGE_MAP(CCard, CWnd)
//{{AFX_MSG_MAP(CCard)
ON_WM_PAINT()
ON_WM_LBUTTONUP()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

void CCard::OnPaint()
{
CPaintDC dc(this); // контекст текущего окна
CDC memDC; // контекст в памяти
memDC.CreateCompatibleDC(&dc); // делаем его совместимым с контекстом окна
CBitmap mBitmap,*oldBitmap;
int rHeight=m_Rect.Height(); // высота прямоугольника будет нужна многократно
// создаем поле нужного размера
mBitmap.CreateCompatibleBitmap(&dc,m_Rect.Width(),rHeight);
// устанавливаем его в контекст в памяти
oldBitmap=(CBitmap*)memDC.SelectObject(&mBitmap);
// рисуем фон - белый прямоугольник
memDC.FillSolidRect(m_Rect.left,m_Rect.top,
m_Rect.Width(),rHeight,RGB(255,255,255));
if(m_grid != NULL){
int i,j,n; // индексы
long m,k,l;
int color;
int off_y=(rHeight-(int)(m_dimy*m_zoom))/2;// смещения для центровки изображения
int off_x=(m_Rect.Width()-(int)(m_dimx*m_zoom))/2;
if(m_ext == 0){ // узел изображается группой пикселов
m=0;
for(i=off_x,l=0; l < m_nx; i += m_grp,l++){
for(j=off_y,k=0; k < m_ny; j += m_grp,k++){
color=(int)((*(m_grid+m)-m_min)/m_grad); // вычисляем цвет
if(istopaint(&color,m_type))
memDC.FillSolidRect(i,rHeight-m_grp-j,m_grp,m_grp,
RGB(0,color,255-color)); // отрисовываем сразу группу пикселов
m++;
}
}
}
else{ // пиксел изображает группу узлов
CPoint pt; // точка для отрисовки пиксела
double avgColor // усредненный цвет группы узлов
for(i=off_x,l=0; l < m_nx-m_grp; i++,l += m_grp){
for(j=off_y,k=0; k < m_ny-m_grp; j++,k += m_grp){
avgColor=0; // суммируем значения узлов
for(m=l; m < l+m_grp; m++)
for(n=k; n < k+m_grp; n++)
avgColor += *(m_grid+m*m_ny+n);
// по среднему значению вычисляем цвет
color=(int)((avgColor/(m_grp*m_grp)-m_min)/m_grad);
pt.x=i; // определяем координаты пиксела
pt.y=rHeight-j;
if(istopaint(&color,m_type))
memDC.SetPixel(pt,RGB(0,color,255-color)); // устанавливаем пиксел
}
}
}
}
// переносим картинку в реальный объект
dc.BitBlt(0,0,m_Rect.Width(),m_Rect.Height(),&memDC,0,0,SRCCOPY);
memDC.DeleteDC(); // уничтожаем контекст в памяти
CWnd::OnPaint();
}

int istopaint(int *color,int type){
if(!type)
return 1;
for(int z=0; z < 255; z += 15){ // разбиваем цвет на интервалы
if(z%30) // "нечетные" пропускаем
continue;
if(*color > z && *color <= z+15){
*color=0;
return 1;
}
}
return(0);
}

/////////////////////////////////////////////////////////////////////////////
// CCard message handlers

void CCard::OnLButtonUp(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
m_type=!m_type;
Invalidate();
CWnd::OnLButtonUp(nFlags, point);
}

FilterEdit.h
#if !defined(AFX_FILTEREDIT_H__361702DF_B444_4C40_A297_85D46FDFFCFC__INCLUDED_)
#define AFX_FILTEREDIT_H__361702DF_B444_4C40_A297_85D46FDFFCFC__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// FilterEdit.h : header file
//

/////////////////////////////////////////////////////////////////////////////
// CFilterEdit window

class CFilterEdit : public CEdit
{
// Construction
public:
CFilterEdit();

// Attributes
public:

// Operations
public:
void SetValidChar(char* pChar) // Set the array with valid characters
{
if(m_nValidChar)
delete [] m_nValidChar;
m_nValidChar = new char[_tcsclen(pChar) + 1];
_tcscpy(m_nValidChar,pChar);
};

// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CFilterEdit)
//}}AFX_VIRTUAL

// Implementation
public:
virtual ~CFilterEdit();

// Generated message map functions
protected:
//{{AFX_MSG(CFilterEdit)
// NOTE - the ClassWizard will add and remove member functions here.
afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags);
//}}AFX_MSG

DECLARE_MESSAGE_MAP()
protected:
char * m_nValidChar;
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_FILTEREDIT_H__361702DF_B444_4C40_A297_85D46FDFFCFC__INCLUDED_)

FilterEdit.cpp
// FilterEdit.cpp : implementation file
//

#include "stdafx.h"
#include "FilterEdit.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CFilterEdit

CFilterEdit::CFilterEdit()
{
m_nValidChar = NULL;
}

CFilterEdit::~CFilterEdit()
{
if (m_nValidChar != NULL)
delete [] m_nValidChar;
}


BEGIN_MESSAGE_MAP(CFilterEdit, CEdit)
//{{AFX_MSG_MAP(CFilterEdit)
// NOTE - the ClassWizard will add and remove mapping macros here.
ON_WM_CHAR()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CFilterEdit message handlers


void
CFilterEdit::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
// контроль вводимых символов непосредственно на этапе ввода
CString s;

if(m_nValidChar == NULL || // таблица допустимых не задана
// или символ допустимый
m_nValidChar != NULL && _tcschr(m_nValidChar,nChar) != NULL)
CEdit::OnChar(nChar, nRepCnt, nFlags); // отдаем базовому классу для обработки
else{
if(!_istprint(nChar))
CEdit::OnChar(nChar, nRepCnt, nFlags);// непечатные - тоже
else
::MessageBeep(-1);
}
}












13






N



9

8

0

5

10

10

10

5