Форум программистов, компьютерный форум CyberForum.ru
Наши страницы

Функция округления чисел - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Не вмещается число http://www.cyberforum.ru/cpp-beginners/thread848190.html
Начал изучать с++ по учебнику, и вот есть такая практическая задачка, нужно первый пример переделать с использованием array вместо масива, вместо long long использовать long double, и расчитать не 16...
C++ Удаление слова из текста Даны текстовый файл и слово. Напечатать те строки файла, которые содержат данное слово без этого слова. Написал прогу которая удаляет из строки лишь первое вхождение слова. Как сделать, чтобы она... http://www.cyberforum.ru/cpp-beginners/thread848184.html
группы символов, разделенные пробелами C++
Помогите написать программу ничего не получается уже сижу 2 дня и не в какую. За ранее спасибо)) группы символов, разделенные пробелами и не содержащие пробелов внутри себя, будем называть...
Создать класс Hexadec1, который будет содержать число в 16-ричной системе C++
1)разработать класс, содержащий два члена (назовем их first, second), и следующие методы: – ввод с клавиатуры Read; – вывод на экран Display; – метод, указанный в задании. Поле first – целое...
C++ Задача http://www.cyberforum.ru/cpp-beginners/thread848162.html
По результатам опроса прошлого года известен список 10 политических деятелей в порядке убывания их популярности. Проведен новый опрос. Каждый из N журналистов (N - заданное число) назвал три...
C++ Вычислить и вывести на экран в виде таблицы значения функции, заданной с помощью ряда Тейлора . Вычислить и вывести на экран в виде таблицы значения функции, заданной с по¬мощью ряда Тейлора, на интервале от хнач до xкон с шагом dx с точностью е. Таблицу снабдить заголовком и шапкой. Каждая... подробнее

Показать сообщение отдельно
Eumi
5 / 5 / 0
Регистрация: 12.06.2012
Сообщений: 58
25.04.2013, 17:55  [ТС]
Цитата Сообщение от Tulosba Посмотреть сообщение
Что пишет-то, скриншот можно? Или скиньте уже куда-нибудь проект полностью.
Вот весь проект, но он и правда очень большой, боюсь вас запутать еще больше.

Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <vector>
#include <math.h>
 
#define PI 3.14159265
 
using namespace std;
 
void ReadData(const char*, vector<double>&, int&, int&);
void ConvertVectorToDoubleArray(vector<double>, double*&, int, int);
int EdgeDetection(double*, double*&, double*&, int, int);
void WriteData(const char*, double*, int, int);
void AlocatePicture(double*&, int, int);
void DelocatingPicture(double*&);
void HoughTransform(double*, double*, double*&, int, int, int, int&);
void RoundingFunction(double, int&);
 
 
int main()
{
    /*The orthogonal egde detection method*/
    double* Gradient;//resulting array
    vector<double> VectorArray;
    double* tab;//input array
    double* AngQ;//An edge gradient angle array
    
    int row=0;
    int column=0;
    tab=NULL;
    Gradient=NULL;
    AngQ=NULL;
        
    ReadData("EdgeInput.txt", VectorArray, row, column);//reading a data and define sizes of matrix
    AlocatePicture(tab, row, column);// alocate a memory for the input array
    ConvertVectorToDoubleArray(VectorArray, tab, row, column);
    AlocatePicture(Gradient, row, column);//alocate a memory for the result array
    AlocatePicture(AngQ, row, column);//alocate memory for an edge gradient angle array
    EdgeDetection(tab, Gradient, AngQ, row, column);
    DelocatingPicture(tab);// deleting the input array
    WriteData("EdgeResult.txt", Gradient, row, column); 
    WriteData("EdgeAngle.txt", AngQ, row, column);
    DelocatingPicture(Gradient);// Delocating the memory for the result array
    DelocatingPicture(AngQ);//deleting the memory for the angle array
 
    /*The Hough Transform*/
    vector<double> VectorArrayGradient;
    vector<double> VectorArrayAngle;
    double* ArrayGradient;// input data(after appling gradient method)
    double* ArrayEdgeAngle;// edge angle array 
    double* HoughTransformArray;//resulting array
 
    int RowGradient=0;// Numbers of rows and columns in EdgeResult file
    int ColumnGradient=0;
    int RowAngle=0;// Numbers of rows and columns in EdgeAngle file
    int ColumnAngle=0;
    int MaxRhoInt=0;
    int MaxTheta=360;
    HoughTransformArray=NULL;
    ArrayGradient=NULL;
    ArrayEdgeAngle=NULL;
 
    ReadData("EdgeResult.txt", VectorArrayGradient, RowGradient, ColumnGradient);// reading input data from Gradient method and define numbers of rows and columns
    ReadData("EdgeAngle.txt", VectorArrayAngle, RowAngle, ColumnAngle);// reading input edge angles and define numbers of rows and columns
    AlocatePicture(ArrayGradient, RowGradient, ColumnGradient);//alocate memory for the gradient array
    AlocatePicture(ArrayEdgeAngle, RowAngle, ColumnAngle);//alocate memory for the angles array
    ConvertVectorToDoubleArray(VectorArrayGradient, ArrayGradient, RowGradient, ColumnGradient); //should be RowGradient = RowAngle, ColumnGradient=ColumnAngle, later in the programm used just one type
    ConvertVectorToDoubleArray(VectorArrayAngle, ArrayEdgeAngle, RowAngle, ColumnAngle);
    /*
    ArrayGradient - result after gradient method
    ArrayEdgeAngle - edge angles after gradient method
    HoughTransformArray - resulting array after Hought transform
    RowGradient, ColumnGradient - numbers of  rowas and columns in input array
    MaxTheta = 360 degrees is constant,MaxRhoInt = 0 - numbers of rows in resulting array define in the function
    */
    HoughTransform(ArrayGradient,ArrayEdgeAngle, HoughTransformArray, RowGradient, ColumnGradient, MaxTheta,MaxRhoInt);
    WriteData("HoughTransformResult.txt", HoughTransformArray, MaxRhoInt, MaxTheta);
    DelocatingPicture(HoughTransformArray);
}
 
/*Reading the file and define sizes of array*/
 
void ReadData(const char* filename, vector<double> &OutputVector, int& row, int& column)
{
    ifstream EdgeInputData(filename);
    if (!EdgeInputData) 
        cerr << "Error! Can't open the input file.\n";
    double InterveningVariable=0;
    while (!EdgeInputData.eof())
    {
        EdgeInputData>>InterveningVariable;
        OutputVector.push_back(InterveningVariable);
        
        if (EdgeInputData.peek() =='\n' || EdgeInputData.peek() == EOF)
            row++;
    }
    column = OutputVector.size()/row;
    
    EdgeInputData.close();
}
 
void AlocatePicture(double* &img, int row, int column)
{
    if (img!=NULL)
        delete []img;
    else
        img=new double[row*column];
}
 
void DelocatingPicture(double* &img)
{
    if (img==NULL)
        return;
    else
    {
        delete []img;
        img=NULL;
    }
}
 
/*Convert vector array to array */ 
void ConvertVectorToDoubleArray(vector<double> InputVector, double* &OutputArray, int row, int column)
{
//  OutputArray=new double[row*column];
    int i=0;
    int j=0;
    for (i=0; i<row; i++)
        for (j=0; j<column; j++)
            OutputArray[i*column + j] = InputVector[i*column + j];
}
 
/* Method of gradient*/
int EdgeDetection(double* InputArray, double* &G, double*& AngleArray, int row, int column)
{
    int i=0;
    int j=0;
    double *GC;
    GC=new double[row*column];
    for (i=0; i<row; i++)
        for(j=0; j<column; j++)
        {
            if (j==0)
                GC[i*column+j] = InputArray[i*column+j] - InputArray[i*column+j+1];//The boundary
            else 
                GC[i*column+j] = InputArray[i*column+j] - InputArray[i*column+j-1];
        }
 
    /*Forming array inlude raw gradients*/
    double *GR;
    GR=new double[row*column];
    for (j=0; j<column; j++)
        for(i=0; i<row; i++)
        {
            if (i==0)
                GR[i*column+j] = InputArray[i*column+j] - InputArray[(i+1)*column+j];//The boundary
            else
                GR[i*column+j] = InputArray[i*column+j] - InputArray[(i-1)*column+j];//The row gradient
                
        }
    /*The edge gradient and angles*/
    for (i=0; i<row; i++)
        for(j=0; j<column; j++)
        {
            G[i*column+j] = abs(GC[i*column + j]) + abs(GR[i*column + j]);//resulting gradient
            if (GR[i*column + j]==0)
                AngleArray[i*column+j]=90;
            else
                AngleArray[i*column+j]=atan(GC[i*column + j]/GR[i*column + j])*180/PI;//angle in degrees
        }
    
    delete [] GR;
    delete [] GC;
    return 0;
}
 
 /*write data in output file*/
void WriteData(const char* filename, double* matrix, int row, int column)
{
    ofstream EdgeResultFile(filename); //Open a file for output
    if (!EdgeResultFile) 
        cerr << "Error! Can't open the output file.\n";
    int i=0;
    int j=0;
    for (i=0; i<row; i++)
    {
        for(j=0; j<column; j++)
        {
            EdgeResultFile << matrix[i*column+j];
            if (j < column - 1) EdgeResultFile << " ";
        }
        if (i < row - 1) EdgeResultFile << "\n";
    }
    EdgeResultFile.close(); 
}
 
void HoughTransform(double* Gradient, double* EdgeAngleArray, double*& HoughTransformArray, int row, int column, int MaxTheta, int& MaxRhoInt)
{
    int i=0;
    int j=0;
    double* AnglePhi;//Phi=arctg(y/x)
    double* ThetaPolarCoordinate;
    double* RhoPolarCoordinate;
    AnglePhi=new double[row*column];
    ThetaPolarCoordinate=new double[row*column];
    RhoPolarCoordinate=new double[row*column];
    for (i=0; i<row; i++)//working with edge gradient angle
        for (j=0;j<column;j++)
        {
            if ((EdgeAngleArray[i*column+j]<90)&&(EdgeAngleArray[i*column+j]>=-90))
                EdgeAngleArray[i*column+j]=EdgeAngleArray[i*column+j]+90;
            else if ((EdgeAngleArray[i*column+j]>=90)&&(EdgeAngleArray[i*column+j]<180))
                EdgeAngleArray[i*column+j]=EdgeAngleArray[i*column+j]-90;
            else if ((EdgeAngleArray[i*column+j]>=-180)&&(EdgeAngleArray[i*column+j]<-90))
                EdgeAngleArray[i*column+j]=EdgeAngleArray[i*column+j]+270;
 
            if (j==0)
                AnglePhi[i*column+j]=90;
            else
                AnglePhi[i*column+j]=atan(i/j)*180/PI;//arctang(y/x)
 
            if (EdgeAngleArray[i*column+j]<AnglePhi[i*column+j])
                ThetaPolarCoordinate[i*column+j]=EdgeAngleArray[i*column+j]+90;
            else
                ThetaPolarCoordinate[i*column+j]=EdgeAngleArray[i*column+j]-90;
            RhoPolarCoordinate[i*column+j]=j*cos(ThetaPolarCoordinate[i*column+j])+i*sin(ThetaPolarCoordinate[i*column+j]);//rho=x*cos(theta)+y*sin(theta)
        }
    i=0;
    j=0;
    double MaxRho=RhoPolarCoordinate[0];//for finding max rho
    for (i=0; i<row; i++)
        for (j=0;j<column;j++)
        {
            if (RhoPolarCoordinate[i*column+j]>MaxRho)
                MaxRho=RhoPolarCoordinate[i*column+j];
        }
    RoundingFunction(MaxRho,MaxRhoInt);
    AlocatePicture(HoughTransformArray, MaxRhoInt, MaxTheta);
    i=0;
    j=0;
    int* IndexRhoM=new int[row*column];
    int* IndexThetaN=new int[row*column];
    for (i=0; i<row; i++)
        for (j=0;j<column;j++)
        {
            double IndexRho=0;
            double IndexTheta=0;
            IndexRho=2*MaxRho-(MaxRho-RhoPolarCoordinate[i*column+j])*(MaxRho-1)/(2*MaxRho);
            IndexTheta=360-((180-ThetaPolarCoordinate[i*column+j])*359/360);
            RoundingFunction(IndexRho,IndexRhoM[i*column+j]);
            RoundingFunction(IndexTheta,IndexThetaN[i*column+j]);
            
        }
    i=0;
    j=0;
    for (i=0;i<MaxRhoInt;i++)
        for (j=0;j<MaxTheta;j++)
                HoughTransformArray[i*360+j]=0;
    int n=column*row;
    i=0;
    j=0;
    for (i=0; i<n; i++)
            HoughTransformArray[IndexRhoM[i]*360+IndexThetaN[i]]=HoughTransformArray[IndexRhoM[i]*360+IndexThetaN[i]]+Gradient[i];
    
    delete []AnglePhi;
    delete []ThetaPolarCoordinate;
    delete []RhoPolarCoordinate;
    delete []IndexRhoM;
    delete []IndexThetaN;
}
 
/*void RoundingFunction(double RoundingVariable, int& ResultVariable)
{
    double IntegerPart=0;
    ResultVariable=0;
    if (modf(abs(RoundingVariable),&IntegerPart)<=0.5)
    {
        if (RoundingVariable>0)
            ResultVariable=floor(RoundingVariable);
        else
            ResultVariable=ceil(RoundingVariable);
    }
    else
    {
        if (RoundingVariable>0)
            ResultVariable=ceil(RoundingVariable);
        else
            ResultVariable=floor(RoundingVariable);
    }
}*/
 
void RoundingFunction(double RoundingVariable, int& ResultVariable)
{
    double IntegerPart=0;
    ResultVariable=0;
    if (RoundingVariable>0)
    {
        if (modf(RoundingVariable,&IntegerPart)<=0.5)
            ResultVariable=floor(RoundingVariable);
        else
            ResultVariable=ceil(RoundingVariable);
    }
    else if (RoundingVariable<0)
    {
        if (modf(RoundingVariable,&IntegerPart)<=-0.5)
            ResultVariable=floor(RoundingVariable);
        else
            ResultVariable=ceil(RoundingVariable);
    }
    else
        ResultVariable=0;
}


Добавлено через 1 минуту
Цитата Сообщение от Tulosba Посмотреть сообщение
Уберите-ка в функции HoughTransform() обращение к HoughTransformArray (закомментируйте) и проверьте наличие ошибок.
Я уже упоминала, что без этой строчки он не выдает ошибок

C++
1
2
for (i=0; i<n; i++)
    HoughTransformArray[IndexRhoM[i]*360+IndexThetaN[i]]=HoughTransformArray[IndexRhoM[i]*360+IndexThetaN[i]]+Gradient[i];
0
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru