소프트웨어 개구리

 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

#include <stdio.h>
#include <string.h>

int main(void)
{
	char c[] = "hello";
	char *d = "bye";
	char e[100];

	printf("%s %s\n", c, d);

	// strlen: string length
	printf("%d\n", strlen(c));
	printf("%d\n", strlen(d));

	// strcmp: string compare
	// strcmp(c, d) : 0 ==> equal
	// strcmp(c, d) : -1(negative) ===> c first
	// strcmp(c, d) : +1(positvie) ==> d first
	printf("comparison result %d\n", strcmp(c, d));

	// strcpy: string copy
	strcpy(e, c); // e = c;
	printf("[%s]-->%d\n", e, strlen(e));

	// strcat: string concatenation
	strcat(e, d);  // e = e + d;
	printf("[%s]-->%d\n", e, strlen(e));
	return 0;
}

 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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

#define SCALE 0.2
#define NUM 5
#define BINS 8

int main(int argc, char** argv)
{
	// the names of images to be compared each other
	string imgNames[NUM] = { "img_dotonbori.jpg", "img_eiffel.jpg", "img2_beach.jpg", "img2_garden.jpg", "img2_grapefarm.jpg" };

	//for (int i = 0; i < NUM; i++)
	//{
	//	cout << imgNames[i] << endl;
	//}

	// read all images and convert to HLS format
	Mat imgs[NUM];
	Mat imgsHLS[NUM];
	for (int i = 0; i < NUM; i++)
	{
		imgs[i] = imread(imgNames[i], IMREAD_COLOR);
		if (imgs[i].data == 0)
		{
			cout << "Unable to read " << imgNames[i] << endl;
			return 0;
		}
		cvtColor(imgs[i], imgsHLS[i], COLOR_BGR2HLS);
	}

	//cout << "Succeeded to read all images" << endl;

	// compute 3D histogram
	Mat histogram[NUM];

	int channel_numbers[] = { 0, 1, 2 };
	for (int i = 0; i < NUM; i++)
	{
		int* number_bins = new int[imgsHLS[i].channels()];
		for (int ch = 0; ch < imgsHLS[i].channels(); ch++)
		{
			number_bins[ch] = BINS;
		}
		float ch_range[] = { 0.0, 255.0 };
		const float *channel_ranges[] = { ch_range, ch_range, ch_range };
		calcHist(&imgsHLS[i], 1, channel_numbers, Mat(), histogram[i], imgsHLS[i].channels(), number_bins, channel_ranges);
		normalize(histogram[i], histogram[i], 1.0);
	}

	cout << "Image Comparison by HISTCMP_CORREL   " << endl;
	for (int i = 0; i < NUM; i++)
	{
		for (int j = i + 1; j < NUM; j++)
		{
			double matching_score = compareHist(histogram[i], histogram[j], HISTCMP_CORREL);
			cout << imgNames[i] << "-" << imgNames[j] << ", " << 1matching_score << endl;
		}
	}
	return 0;
}

 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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

#define SCALE 0.2
#define NUM 5
#define BINS 8

int main(int argc, char** argv)
{
	// the names of images to be compared each other
	string imgNames[NUM] = { "img_dotonbori.jpg", "img_eiffel.jpg", "img2_beach.jpg", "img2_garden.jpg", "img2_grapefarm.jpg" };

	//for (int i = 0; i < NUM; i++)
	//{
	//	cout << imgNames[i] << endl;
	//}

	// read all images and convert to HLS format
	Mat imgs[NUM];
	Mat imgsHLS[NUM];
	for (int i = 0; i < NUM; i++)
	{
		imgs[i] = imread(imgNames[i], IMREAD_COLOR);
		if (imgs[i].data == 0)
		{
			cout << "Unable to read " << imgNames[i] << endl;
			return 0;
		}
		cvtColor(imgs[i], imgsHLS[i], COLOR_BGR2HLS);
	}

	//cout << "Succeeded to read all images" << endl;

	// compute 3D histogram
	Mat histogram[NUM];

	int channel_numbers[] = { 0, 1, 2 };
	for (int i = 0; i < NUM; i++)
	{
		int* number_bins = new int[imgsHLS[i].channels()];
		for (int ch = 0; ch < imgsHLS[i].channels(); ch++)
		{
			number_bins[ch] = BINS;
		}
		float ch_range[] = { 0.0, 255.0 };
		const float *channel_ranges[] = { ch_range, ch_range, ch_range };
		calcHist(&imgsHLS[i], 1, channel_numbers, Mat(), histogram[i], imgsHLS[i].channels(), number_bins, channel_ranges);
		cout << imgNames[i] << "-----------------------" << endl;
		for (int x = 0; x < BINS; x++)
		{
			for (int y = 0; y < BINS; y++)
			{
				for (int z = 0; z < BINS; z++)
				{
					cout << histogram[i].at<float>(x, y, z) << " ";
				}
			}
		}
		cout << endl;
	}
	return 0;
}

 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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

#define SCALE 0.2


int main(int argc, char** argv)
{
	if (argc != 2)
	{
		cout << " Provide image name to read" << endl;
		return -1;
	}

	Mat inputImg, dispImg, disp2Img;
	Mat hlsImg;

	inputImg = imread(argv[1], IMREAD_COLOR); // read in BGR format

	if (inputImg.data == 0)
	{
		cout << "Unable to read " << argv[1] << endl;
		return 0;
	}

	// inputImg is too large to be shown. 
	// use scaled-down dispImg instead just for display
	// use inputImg for the histogram calculation
	resize(inputImg, dispImg, Size(), SCALE, SCALE, CV_INTER_AREA);

	cvtColor(dispImg, hlsImg, COLOR_BGR2HLS_FULL);

	vector<Mat> channels(hlsImg.channels());
	split(hlsImg, channels);
	equalizeHist(channels[1], channels[1]);
	merge(channels, hlsImg);
	cvtColor(hlsImg, disp2Img, COLOR_HLS2BGR_FULL);

	namedWindow("Original", CV_WINDOW_AUTOSIZE);
	namedWindow("After luminacense equalization", CV_WINDOW_AUTOSIZE);

	moveWindow("Original", 100, 100);
	moveWindow("After luminacense equalization", 120, 120);

	imshow("Original", dispImg);
	imshow("After luminacense equalization", disp2Img);

	waitKey(0);
	return 0;
}

 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

#include <stdio.h>

int main(void)
{
	int n;
	int sum = 0;
	printf("숫자를 입력하세요: ");
	scanf("%d", &n);

	for (int i = 1; i <= n; i++)
	{
		if (n % i == 0)
		{
			int j;
			// i : 약수
			for (j = 2; j <= i - 1; j++)
			{
				if (i%j == 0)
				{
					break;
				}
			}
			if (j == i)
			{
				sum = sum + i;
			}
			else
			{
				// 소수아님
			}

		}
	}
	printf("%d ", sum);
}

 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

#include <stdio.h>

int main(void)
{
	int n;
	int i = 3;
	int p = 1; // previous
	int pp = 1; // previous previous
	int me;
	printf("숫자를 입력하세요: ");
	scanf("%d", &n);

	if (n <= 2)
	{
		printf("1");
		return 0;
	}
	else
	{
		while (i <= n)
		{
			me = pp + p;
			pp = p;
			p = me;
			i++;
		}
		printf("%d ", me);
	}

}

 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

#include <stdio.h>

int main(void)
{
	int n;
	int i;
	int r;
	int upper;
	int target;
	printf("숫자를 입력하세요: ");
	scanf("%d", &n);

	// calculate the remainder by 5
	r = n % 5;
	upper = 5 - r;
	if (r < upper)
	{
		target = n - r;
	}
	else // r > upper
	{
		target = n + upper;
	}

	for (i = 1; i <= target; i++)
	{
		printf("%d ", i);
	}
}

  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

#include <stdio.h>
#include <stdlib.h>

struct node
{
	int data;
	struct node *prev;
	struct node *next;
};
struct node *head = 0;

// returns the pointer to the node which has _data
// returns null if no node has _data
struct node* whereIsNode(int _data)
{
	struct node *temp = head;

	while (temp != 0)
	{
		if (temp->data == _data)
		{
			break;
		}
		temp = temp->next;
	}
	return temp;

}





void addToDLL(int n)
{
	struct node *cur;
	cur = (struct node *)malloc(sizeof(struct node));
	cur->next = cur->prev = 0;
	cur->data = n;

	// check if there is no node
	if (head == 0)
	{
		head = cur;
		return;
	}

	// find the last node
	{
		struct node *temp = head;
		while (temp->next != 0)
		{
			temp = temp->next;
		}
		temp->next = cur;
		cur->prev = temp;
		return;
	}
}

void showDLL()
{
	struct node *cur = head;
	while (cur != 0)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
}

void showNeighbors(int _data)
{
	struct node *temp;
	temp = whereIsNode(_data);

	if (temp == 0)
	{
		printf("-999\n");
		return;
	}
	else
	{
		// prev prev
		if (temp->prev != 0)
		{
			if (temp->prev->prev != 0)
			{
				printf("%d ", temp->prev->prev->data);
			}
			else
			{
				printf("-999 ");
			}
		}
		else
		{
			printf("-999 ");
		}

		// next next
		if (temp->next != 0)
		{
			if (temp->next->next != 0)
			{
				printf("%d \n", temp->next->next->data);
			}
			else
			{
				printf("-999 \n");
			}
		}
		else
		{
			printf("-999 \n");
		}

	}


}

int main(void)
{
	addToDLL(1);
	addToDLL(2);
	addToDLL(3);
	addToDLL(4);
	addToDLL(5);
	addToDLL(6);
	addToDLL(7);
	addToDLL(8);

	showNeighbors(5); // 3, 7
	showNeighbors(8); // 6, -999
	showNeighbors(1); // -999, 3
	showNeighbors(100); // -999

	return 0;
}

  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

#include <stdio.h>
#include <stdlib.h>

struct node
{
	int data;
	struct node *prev;
	struct node *next;
};
struct node *head = 0;

struct statNode
{
	int data;
	int freq;
	struct statNode *prev;
	struct statNode *next;
};
struct statNode *sHead = 0;


// returns the pointer to the node which has bigger data than _data
// returns null if _data is the biggest
struct statNode *whoIsBigger(int _data)
{
	struct statNode *temp = sHead;

	while (temp != 0)
	{
		if (temp->data > _data)
		{
			break;
		}
		temp = temp->next;
	}
	return temp;

}

// returns the pointer to the node which has _data
// returns null if no node has _data
struct statNode* whereIsNode(int _data)
{
	struct statNode *temp = sHead;

	while (temp != 0)
	{
		if (temp->data == _data)
		{
			break;
		}
		temp = temp->next;
	}
	return temp;

}

void showStatDLL()
{
	struct statNode *temp = sHead;
	while (temp != 0)
	{
		printf("%d %d ", temp->data, temp->freq);
		temp = temp->next;
	}
}

void addToStatDLL(int _data)
{
	// 1. determine which node has _data
	struct statNode *temp;
	temp = whereIsNode(_data);
	if (temp != 0) // temp is pointing to the node having _data
	{
		temp->freq += 1;
		return;
	}
	else  // no node has _data
	{
		struct statNode *cur;
		cur = (struct statNode *)malloc(sizeof(struct statNode));
		cur->data = _data;
		cur->freq = 1;
		cur->next = cur->prev = 0;

		if (sHead == 0)
		{
			sHead = cur;
			return;
		}
		else
		{
			struct statNode *temp;
			temp = whoIsBigger(_data);
			if (temp == 0)  // _data is the biggest
			{
				// add to the last location
				struct statNode *final = sHead;
				while (final->next != 0)
				{
					final = final->next;
				}
				final->next = cur;
				cur->prev = final;
				return;

			}
			else
			{
				if (temp == sHead)  // _data is the smallest
				{
					// add to the first location
					cur->next = sHead;
					sHead = cur;
					cur->next->prev = cur;
					return;
				}
				else
				{
					// insert _data before temp
					cur->next = temp;
					cur->prev = temp->prev;
					temp->prev = cur;
					cur->prev->next = cur;
					return;
				}
			}
		}
	}
}



void addToDLL(int n)
{
	struct node *cur;
	cur = (struct node *)malloc(sizeof(struct node));
	cur->next = cur->prev = 0;
	cur->data = n;

	// check if there is no node
	if (head == 0)
	{
		head = cur;
		return;
	}

	// find the last node
	{
		struct node *temp = head;
		while (temp->next != 0)
		{
			temp = temp->next;
		}
		temp->next = cur;
		cur->prev = temp;
		return;
	}
}

void showDLL()
{
	struct node *cur = head;
	while (cur != 0)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
}

int main(void)
{
	addToDLL(1);
	addToDLL(4);
	addToDLL(3);
	addToDLL(2);
	addToDLL(1);
	addToDLL(3);
	addToDLL(2);
	addToDLL(1);

	struct node *temp = head;
	while (temp != 0)
	{
		addToStatDLL(temp->data);
		temp = temp->next;
	}

	showStatDLL();
	return 0;
}

 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

package univ.embedded.timer;

import javax.swing.*;

public class TimerLogic extends Thread 
{
	private JLabel timeLabel = null;
	private TimerUI tui = null;
	
	public TimerLogic()
	{
		
	}
	
	public TimerLogic(JLabel _timeLabel)
	{
		timeLabel = _timeLabel;
	}
	
	public TimerLogic(JLabel _timeLabel, TimerUI _tui)
	{
		timeLabel = _timeLabel;
		tui = _tui;
	}
	
	
	public void run()
	{
		for (int i = 10; i >= 0; i--)
		{
			timeLabel.setText(""+i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		tui.activateButton();
		
	}
	

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import univ.embedded.timer.*;

public class MyTest {

	public static void main(String[] argv)
	{
		TimerUI tu = new TimerUI();
	}
	
}

 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

package univ.embedded.timer;

import java.awt.Color;
import java.awt.event.*;

import javax.swing.*;

public class TimerUI extends JFrame 
implements ActionListener
{
	JLabel timeLabel = null;
	JButton startButton = null;

	@Override
	public void actionPerformed(ActionEvent e) 
	{
		//TimerLogic lc = new TimerLogic(timeLabel);
		//lc.start();
		startButton.setText("NO TOUCH");
		startButton.setEnabled(false);
		
		(new TimerLogic(timeLabel, this)).start();
	}
	
	public void activateButton()
	{
		startButton.setText("Start");
		startButton.setEnabled(true);
	}
	
	public TimerUI()
	{
		setSize(300, 200);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setTitle("10 Sec. Timer");
		
		timeLabel = new JLabel("10");
		startButton = new JButton("Start");
		startButton.addActionListener(this);
		
		setLayout(null);
		timeLabel.setSize(100, 60);
		startButton.setSize(100, 60);
		
		timeLabel.setLocation(50, 20);
		startButton.setLocation(50, 100);
		
		add(timeLabel);
		add(startButton);
		
		
		setVisible(true);
	}

	
}

  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

#include <stdio.h>

#define SZ 5

int queue[5];
int front = 0;
int rear = 0;

int isEmpty()
{
	return (front == rear);
}

int isFull()
{
	return ((rear + 1) % SZ == front);
}

// put the data d into the queue
// only if there is room.
void enque(int d)
{
	if (isFull() == 1)
	{
		return;
	}

	queue[rear] = d;
	// consider that the queue is circular,,
	rear = (rear + 1) % SZ;

	return;
}

// take out one item from the queue
// returns -999 if the queue is empty.
int deque()
{
	if (isEmpty() == 1)
	{
		return -999;
	}

	{
		int temp = queue[front];
		front = (front + 1) % SZ;
		return temp;
	}

}


int main(void)
{

	// test case for the full queue
	for (int i = 0; i <10; i++)
	{
		enque(i);
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d\n", deque());
	}

#if 0
	printf("%d\n", deque());
#endif

#if 0
	enque(3);
	enque(4);
	enque(5);
	printf("%d\n", deque());
	printf("%d\n", deque());
	printf("%d\n", deque());
#endif
	return 0;
}




#if 0

#include <stdio.h>

#define SZ 5

int stack[5];
int top = -1;

// check the stack is empty
// it returns 1 if so,
//    returns 0 otherwise
int isEmpty()
{
	return (top == -1);
}

// check the stack is full
// it returns 1 if so,
//    returns 0 otherwise
int isFull()
{
	// (SZ-1) is the last index of the stack
	return (top == (SZ - 1));
}

// put the data d into the stack
// if the stack is full, do nothing, just return
void push(int d)
{
	if (isFull() == 1)
	{
		return;
	}
	top++;  // because the initial value of top is -1
	stack[top] = d;

	// stack[++top] = d; the above two lines can be 
	//                   written in one line.

	return;
}

// take out one item from the stack
// returns -999 if the stack is empty.
int pop()
{
	if (isEmpty() == 1)
	{
		return -999;  // -999 means the stack is empty.
	}

	top--;
	return stack[top + 1];

	/* the above two lines mean the following.
	{
		int temp = stack[top];
		top--;
		return temp;
	}
	*/

}
int main(void)
{
#if 0
	// test case forf the full stack
	for (int i = 0; i <10; i++)
	{
		push(i);
	}
	printf("%d\n", pop());
#endif
#if 0
	// test case for the empty stack
	printf("%d \n", pop());
#endif
#if 0
	push(1);
	push(2);
	push(3);
	for (int i = 0; i < 3; i++)
	{
		printf("%d\n", pop());
	}
#endif
	return 0;
}

#endif

 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

#include <stdio.h>

#define SZ 5

int stack[5];
int top = -1;

// check the stack is empty
// it returns 1 if so,
//    returns 0 otherwise
int isEmpty()
{
	return (top == -1);
}

// check the stack is full
// it returns 1 if so,
//    returns 0 otherwise
int isFull()
{
	// (SZ-1) is the last index of the stack
	return (top == (SZ - 1));
}

// put the data d into the stack
// if the stack is full, do nothing, just return
void push(int d)
{
	if (isFull() == 1)
	{
		return;
	}
	top++;  // because the initial value of top is -1
	stack[top] = d;

	// stack[++top] = d; the above two lines can be 
	//                   written in one line.

	return;
}

// take out one item from the stack
// returns -999 if the stack is empty.
int pop()
{
	if (isEmpty() == 1)
	{
		return -999;  // -999 means the stack is empty.
	}

	top--;
	return stack[top + 1];

	/* the above two lines mean the following.
	{
		int temp = stack[top];
		top--;
		return temp;
	}
	*/

}
int main(void)
{
#if 0
	// test case forf the full stack
	for (int i = 0; i <10; i++)
	{
		push(i);
	}
	printf("%d\n", pop());
#endif
#if 0
	// test case for the empty stack
	printf("%d \n", pop());
#endif
#if 0
	push(1);
	push(2);
	push(3);
	for (int i = 0; i < 3; i++)
	{
		printf("%d\n", pop());
	}
#endif
	return 0;
}

  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

#include <stdio.h>
#include <stdlib.h>

struct node 
{
	int data;
	struct node *next;
	struct node *prev;
};

struct node *head;

void addToDLL(int n)
{
	struct node *cur;
	cur = (struct node *)malloc(sizeof(struct node));
	cur->next = cur->prev = 0;
	cur->data = n;

	// check if there is no node
	if (head == 0)
	{
		head = cur;
		return;
	}

	// find the last node
	{
		struct node *temp = head;
		while (temp->next != 0)
		{
			temp = temp->next;
		}
		temp->next = cur;
		cur->prev = temp;
		return;
	}
}

void showDLL()
{
	struct node *cur = head;
	while (cur != 0)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
}

// find the node with data n
// delete it from DLL
void delFromDLL(int n)
{
	// locate the node with data n
	struct node *cur = head;
	while (cur != 0)
	{
		if (cur->data == n)
		{
			// found the node with data n
			break;
		}
		cur = cur->next;
	}
	
	if (cur == 0)  // failed to find the node with n
	{
		return;
	}

	// now, cur is pointing to the node with n


	// case 1. cur is the first node of DLL
	if (cur == head)
	{
		head = head->next;
		free(cur);
		if (head != 0)
		{
			head->prev = 0;
		}
	}
	else if (cur->next == 0) {
		// case 2.cur is the last node of DLL
		cur->prev->next = 0;
		free(cur);
	}
	else // case3. cur is a middle node
	{
		// connect the previous one with the next one
		cur->prev->next = cur->next;
		// connect the next one with the previous one
		cur->next->prev = cur->prev;
		free(cur);
	}

}

// locate the node with n
// add a new with with m
// if direction == 1, add m mode to the next location
//    direction == -1, add m node to the previous location
void insertToDLL(int n, int m, int direction)
{
	// locate the node with n
	struct node *cur = head;
	while (cur != 0)
	{
		if (cur->data == n)
		{
			// found the node with n
			break;
		}
		cur = cur->next;
	}

	if (cur == 0) // failed to find the node with n
	{
		// thank you
		return;
	}
	else
	{
		// create a new node having m
		struct node *newbie;
		newbie = (struct node *)malloc(sizeof(struct node));
		newbie->next = newbie->prev = 0;
		newbie->data = m;

		// case 1: if n node is the head node
		if (cur == head)
		{
			if (direction == -1)
			{ // add the newbie to the previous location
				head = newbie;
				newbie->next = cur;
				cur->prev = newbie;
				return;
			}
			else
			{ // add the newbie to the next location
				// case 1. cur has a next node
				if (cur->next != 0)
				{
					newbie->next = cur->next;
					newbie->prev = cur;
					cur->next->prev = newbie;
					cur->next = newbie;
					return;
				}
				else
				{ // case 2. cur has no next node
					newbie->prev = cur;
					cur->next = newbie;
					return;
				}
			}
		}
		else if (cur->next != 0)
		{ // case 2: cur is neither the first nor the last node.
			if (direction == 1)  // next location
			{
				newbie->next = cur->next;
				newbie->prev = cur;
				cur->next = newbie;
				newbie->next->prev = newbie;
				return;
			}
			else  // previous location
			{
				newbie->next = cur;
				newbie->prev = cur->prev;
				cur->prev = newbie;
				newbie->prev->next = newbie;
				return;
			}
		}
		else
		{
			// case 3. cur is the last node
			if (direction == 1)
			{  // it is the same with the addtion
				cur->next = newbie;
				newbie->prev = cur;
				return;
			}
			else // add to the previous location
			{
				newbie->next = cur;
				newbie->prev = cur->prev;
				cur->prev = newbie;
				newbie->prev->next = newbie;
				return;
			}
		}



	}


}

int main(void)
{
	addToDLL(1);
	addToDLL(2);
	addToDLL(3);
	addToDLL(4);
	
	insertToDLL(4, 10, -1);

	showDLL();

	return 0;
}

  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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

#define SCALE 0.2

/* given hue value, which is original_hue/2
   calculate a corresponding RGB.
   It is assumed that luminance is 0.5 (50%), and saturation is 1.0(100%) 
*/
Scalar cvtHLStoRGB(double hue)
{
	double _hue = 2 * hue;
	double C = 1.0;
	double X = (double)(1.0 - abs((double)(((int)(_hue/60.0) % 2) - 1)));
	double m = 0.0;

	double R = 0.0;
	double G = 0.0;
	double B = 0.0;
	if (_hue >= 0 && _hue < 60)
	{
		R = C*255.0;
		G = X*255.0;
	}
	else if (_hue >= 60 && _hue < 120)
	{
		R = X*255.0;
		G = C*255.0;
	}
	else if (_hue >= 120 && _hue < 180)
	{
		G = C*255.0;
		B = X*255.0;
	}
	else if (_hue >= 180 && _hue < 240)
	{
		G = X*255.0;
		B = C*255.0;
	}
	else if (_hue >= 240 && _hue < 300)
	{
		R = X*255.0;
		B = C*255.0;
	}
	else if (_hue >= 300 && _hue < 360)
	{
		R = C*255.0;
		B = X*255.0;
	}
	return Scalar(B, G, R);
}

int main(int argc, char** argv)
{
	if (argc != 2)
	{
		cout << " Provide image name to read" << endl;
		return -1;
	}

	Mat inputImg, dispImg;
	Mat hlsImg;

	inputImg = imread(argv[1], CV_LOAD_IMAGE_COLOR);

	// inputImg is too large to be shown. 
	// use scaled-down dispImg instead just for display
	// use inputImg for the histogram calculation
	resize(inputImg, dispImg, Size(), SCALE, SCALE, CV_INTER_AREA);

	cvtColor(inputImg, hlsImg, CV_BGR2HLS);

	// separate into three images with only one channel, H, L, and S
	vector<Mat> hls_images(3);
	split(hlsImg, hls_images);  

	//--------------------------------------
	// H, L, S 채널별로 histogram을 계산
	//--------------------------------------

	// Prepare three histograms for H, L, S
	MatND* histogram = new MatND[hlsImg.channels()];  

	// Each image has only one channel.
	const int* channel_numbers = { 0 };
	
	float channel_range[] = { 0.0, 255.0 };
	const float* channel_ranges = channel_range;
	// 255-bins for histogram
	int number_bins = 255;

	// calculate histograms one at a time, H, L, and S
	// histogram[0] contains H's
	// histogram[1] contains L's
	// histogram[2] contains S's
	for (int chan = 0; chan < hlsImg.channels(); chan++)
	{
		calcHist(&(hls_images[chan]), 1, channel_numbers, Mat(),
			histogram[chan], 1, &number_bins, &channel_ranges);
	}

	//------------------------
	// Plot the histograms in each image
	//------------------------
	int hist_w = 512; int hist_h = 400;
	int bin_w = cvRound((double)hist_w / number_bins);

	// histogram image for H channel
	Mat histImageH(hist_h, hist_w, CV_8UC3, Scalar(0, 0, 0));
	normalize(histogram[0], histogram[0], 0, histImageH.rows, NORM_MINMAX, -1, Mat());

	// histogram image for L channel
	Mat histImageL(hist_h, hist_w, CV_8UC3, Scalar(0, 0, 0));
	normalize(histogram[1], histogram[1], 0, histImageL.rows, NORM_MINMAX, -1, Mat());

	// histogram image for S channel
	Mat histImageS(hist_h, hist_w, CV_8UC3, Scalar(0, 0, 0));
	normalize(histogram[2], histogram[2], 0, histImageS.rows, NORM_MINMAX, -1, Mat());

	for (int i = 1; i < number_bins; i++)
	{
		line(histImageH, Point(bin_w*(i - 1), hist_h - cvRound(histogram[0].at<float>(i - 1))),
			Point(bin_w*(i), hist_h - cvRound(histogram[0].at<float>(i))),
			cvtHLStoRGB((double)i), 2, 8, 0);
		line(histImageL, Point(bin_w*(i - 1), hist_h - cvRound(histogram[1].at<float>(i - 1))),
			Point(bin_w*(i), hist_h - cvRound(histogram[1].at<float>(i))),
			Scalar(0, 255, 0), 2, 8, 0);
		line(histImageS, Point(bin_w*(i - 1), hist_h - cvRound(histogram[2].at<float>(i - 1))),
			Point(bin_w*(i), hist_h - cvRound(histogram[2].at<float>(i))),
			Scalar(0, 0, 255), 2, 8, 0);
	}

	namedWindow("Original", CV_WINDOW_AUTOSIZE);
	namedWindow("histogramH", CV_WINDOW_AUTOSIZE);
	namedWindow("histogramL", CV_WINDOW_AUTOSIZE);
	namedWindow("histogramS", CV_WINDOW_AUTOSIZE);

	moveWindow("Original", 100, 100);
	moveWindow("histogramH", 120, 120);
	moveWindow("histogramL", 140, 140);
	moveWindow("histogramS", 160, 160);

	imshow("Original", dispImg);
	imshow("histogramH", histImageH);
	imshow("histogramL", histImageL);
	imshow("histogramS", histImageS);

	waitKey(0);
	return 0;
}

 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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

#define SCALE 0.2

int main(int argc, char** argv)
{


	if (argc != 2)
	{
		cout << " Provide image name to read" << endl;
		return -1;
	}

	Mat inputImg;

	inputImg = imread(argv[1], CV_LOAD_IMAGE_COLOR);
	resize(inputImg, inputImg, Size(), SCALE, SCALE, CV_INTER_AREA);

	MatND histogramB, histogramG, histogramR;
	const int channel_numbersB[] = { 0 };  // Blue
	const int channel_numbersG[] = { 1 };  // Green
	const int channel_numbersR[] = { 2 };  // Red
	float channel_range[] = { 0.0, 255.0 };
	const float* channel_ranges = channel_range;
	int number_bins = 255;

	// R, G, B별로 각각 히스토그램을 계산한다.
	calcHist(&inputImg, 1, channel_numbersB, Mat(), histogramB, 1, &number_bins, &channel_ranges);
	calcHist(&inputImg, 1, channel_numbersG, Mat(), histogramG, 1, &number_bins, &channel_ranges);
	calcHist(&inputImg, 1, channel_numbersR, Mat(), histogramR, 1, &number_bins, &channel_ranges);

	// Plot the histogram
	int hist_w = 512; int hist_h = 400;
	int bin_w = cvRound((double)hist_w / number_bins);

	Mat histImageB(hist_h, hist_w, CV_8UC3, Scalar(0, 0, 0));
	normalize(histogramB, histogramB, 0, histImageB.rows, NORM_MINMAX, -1, Mat());

	Mat histImageG(hist_h, hist_w, CV_8UC3, Scalar(0, 0, 0));
	normalize(histogramG, histogramG, 0, histImageG.rows, NORM_MINMAX, -1, Mat());

	Mat histImageR(hist_h, hist_w, CV_8UC3, Scalar(0, 0, 0));
	normalize(histogramR, histogramR, 0, histImageR.rows, NORM_MINMAX, -1, Mat());

	for (int i = 1; i < number_bins; i++)
	{
		
		line(histImageB, Point(bin_w*(i - 1), hist_h - cvRound(histogramB.at<float>(i - 1))),
			Point(bin_w*(i), hist_h - cvRound(histogramB.at<float>(i))),
			Scalar(255, 0, 0), 2, 8, 0);
		line(histImageG, Point(bin_w*(i - 1), hist_h - cvRound(histogramG.at<float>(i - 1))),
			Point(bin_w*(i), hist_h - cvRound(histogramG.at<float>(i))),
			Scalar(0, 255, 0), 2, 8, 0);

		line(histImageR, Point(bin_w*(i - 1), hist_h - cvRound(histogramR.at<float>(i - 1))),
			Point(bin_w*(i), hist_h - cvRound(histogramR.at<float>(i))),
			Scalar(0, 0, 255), 2, 8, 0);
	
	}


	namedWindow("Original", CV_WINDOW_AUTOSIZE);
	namedWindow("HistogramB", CV_WINDOW_AUTOSIZE);
	namedWindow("HistogramG", CV_WINDOW_AUTOSIZE);
	namedWindow("HistogramR", CV_WINDOW_AUTOSIZE);

	moveWindow("Original", 100, 100);
	moveWindow("HistogramB", 110, 110);
	moveWindow("HistogramG", 120, 120);
	moveWindow("HistogramR", 130, 130);

	imshow("Original", inputImg);
	imshow("HistogramB", histImageB);
	imshow("HistogramG", histImageG);
	imshow("HistogramR", histImageR);

	waitKey(0);
	return 0;
}

 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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

#define SCALE 0.2

int main(int argc, char** argv)
{

	if (argc != 2)
	{
		cout << " Provide image name to read" << endl;
		return -1;
	}

	Mat inputImg;
	Mat greyImg;

	inputImg = imread(argv[1], CV_LOAD_IMAGE_COLOR);
	resize(inputImg, inputImg, Size(), SCALE, SCALE, CV_INTER_AREA);

	// inputImg를 gray영상(greyImg)으로 변환한다.
	cvtColor(inputImg, greyImg, CV_BGR2GRAY);

	MatND histogram;
	const int* channel_numbers = { 0 };
	float channel_range[] = { 0.0, 255.0 };
	const float* channel_ranges = channel_range;
	int number_bins = 255;

	calcHist(&greyImg, 1, channel_numbers, Mat(), histogram, 1, &number_bins, &channel_ranges);

	// Plot the histogram
	int hist_w = 512; int hist_h = 400;
	int bin_w = cvRound((double)hist_w / number_bins);

	Mat histImage(hist_h, hist_w, CV_8UC1, Scalar(0, 0, 0));
	normalize(histogram, histogram, 0, histImage.rows, NORM_MINMAX, -1, Mat());

	for (int i = 1; i < number_bins; i++)
	{
		line(histImage, Point(bin_w*(i - 1), hist_h - cvRound(histogram.at<float>(i - 1))),
			Point(bin_w*(i), hist_h - cvRound(histogram.at<float>(i))),
			Scalar(255, 0, 0), 2, 8, 0);
	}

	namedWindow("Original", CV_WINDOW_AUTOSIZE);
	namedWindow("Histogram", CV_WINDOW_AUTOSIZE);
	
	moveWindow("Original", 100, 100);
	moveWindow("Histogram", 120, 120);

	imshow("Original", greyImg);
	imshow("Histogram", histImage);

	waitKey(0);
	return 0;
}

 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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

/*
img의 전체 픽셀중 noise_ratio 퍼센트 만큼의
픽셀을 salt & pepper noise로 바꾼다.
*/
void addSaltAndPepperNoise(Mat& img, double noise_ratio)
{
	int rows = img.rows;
	int cols = img.cols;
	int ch = img.channels();
	int num_of_noise_pixels = (int)((double)(rows * cols * ch)*noise_ratio);

	for (int i = 0; i < num_of_noise_pixels; i++)
	{
		int r = rand() % rows;  // noise로 바꿀 행을 임의로 선택
		int c = rand() % cols;  // noise로 바꿀 열을 임의로 선택
		int _ch = rand() % ch;  // noise로 바꿀 채널의 임의로 선택

		// img.ptr<uchar>(r)은 r번째 행의 첫번째 픽셀, 첫번째 채널에 대한 주소값을 반환한다.
		uchar* pixel = img.ptr<uchar>(r) +(c*ch) + _ch; // noise로 바꿀 정확한 위치를 계산

		*pixel = (rand() % 2 == 1) ? 255 : 0; // black(0) 혹은 white(255)로 교체
	}
}

int main(int argc, char** argv)
{

	if (argc != 2)
	{
		cout << " Provide image name to read" << endl;
		return -1;
	}

	Mat inputImg;
	Mat spImg;

	inputImg = imread(argv[1], CV_LOAD_IMAGE_COLOR);
	resize(inputImg, inputImg, Size(), 0.25, 0.25, CV_INTER_AREA);

	spImg = inputImg.clone();
	addSaltAndPepperNoise(spImg, 0.05);

	Mat localAvgImg;
	// Noise 제거를 위해 3 by 3 매트릭스를 이용하여
	// local averaing을 시행.
	blur(spImg, localAvgImg, Size(5, 5));  

	Mat gaussianSmoothedImg;
	GaussianBlur(spImg, gaussianSmoothedImg, Size(5, 5), 1.5);

	Mat medianFilteredImg;
	medianBlur(spImg, medianFilteredImg, 3);

	namedWindow("Original", CV_WINDOW_AUTOSIZE);
	namedWindow("SaltAndPepper", CV_WINDOW_AUTOSIZE);
	namedWindow("LocalAveraging", CV_WINDOW_AUTOSIZE);
	namedWindow("GaussianSmoothing", CV_WINDOW_AUTOSIZE);
	namedWindow("MedianFiltered", CV_WINDOW_AUTOSIZE);

	moveWindow("Original", 100, 100);
	moveWindow("SaltAndPepper", 120, 120);
	moveWindow("LocalAveraging", 140, 140);
	moveWindow("GaussianSmoothing", 150, 150);
	moveWindow("MedianFiltered", 160, 160);

	imshow("Original", inputImg);
	imshow("SaltAndPepper", spImg);
	imshow("LocalAveraging", localAvgImg);
	imshow("GaussianSmoothing", gaussianSmoothedImg);
	imshow("MedianFiltered", medianFilteredImg);

	waitKey(0);
	return 0;
}

 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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

/*
img의 전체 픽셀중 noise_ratio 퍼센트 만큼의
픽셀을 salt & pepper noise로 바꾼다.
*/
void addSaltAndPepperNoise(Mat& img, double noise_ratio)
{
	int rows = img.rows;
	int cols = img.cols;
	int ch = img.channels();
	int num_of_noise_pixels = (int)((double)(rows * cols * ch)*noise_ratio);

	for (int i = 0; i < num_of_noise_pixels; i++)
	{
		int r = rand() % rows;  // noise로 바꿀 행을 임의로 선택
		int c = rand() % cols;  // noise로 바꿀 열을 임의로 선택
		int _ch = rand() % ch;  // noise로 바꿀 채널의 임의로 선택

		// img.ptr<uchar>(r)은 r번째 행의 첫번째 픽셀, 첫번째 채널에 대한 주소값을 반환한다.
		uchar* pixel = img.ptr<uchar>(r) +(c*ch) + _ch; // noise로 바꿀 정확한 위치를 계산

		*pixel = (rand() % 2 == 1) ? 255 : 0; // black(0) 혹은 white(255)로 교체
	}
}

int main(int argc, char** argv)
{

	if (argc != 2)
	{
		cout << " Provide image name to read" << endl;
		return -1;
	}

	Mat inputImg;
	Mat spImg;

	inputImg = imread(argv[1], CV_LOAD_IMAGE_COLOR);
	resize(inputImg, inputImg, Size(), 0.25, 0.25, CV_INTER_AREA);

	spImg = inputImg.clone();
	addSaltAndPepperNoise(spImg, 0.05);

	Mat localAvgImg;
	// Noise 제거를 위해 3 by 3 매트릭스를 이용하여
	// local averaing을 시행.
	blur(spImg, localAvgImg, Size(5, 5));  

	Mat gaussianSmoothedImg;
	GaussianBlur(spImg, gaussianSmoothedImg, Size(5, 5), 1.5);

	namedWindow("Original", CV_WINDOW_AUTOSIZE);
	namedWindow("SaltAndPepper", CV_WINDOW_AUTOSIZE);
	namedWindow("LocalAveraging", CV_WINDOW_AUTOSIZE);
	namedWindow("GaussianSmoothing", CV_WINDOW_AUTOSIZE);

	moveWindow("Original", 100, 100);
	moveWindow("SaltAndPepper", 120, 120);
	moveWindow("LocalAveraging", 140, 140);
	moveWindow("GaussianSmoothing", 150, 150);

	imshow("Original", inputImg);
	imshow("SaltAndPepper", spImg);
	imshow("LocalAveraging", localAvgImg);
	imshow("GaussianSmoothing", gaussianSmoothedImg);

	waitKey(0);
	return 0;
}

 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

public class CalculatorLogic 
{

	boolean firstNum;
	boolean opSymbol;
	boolean secondNum;
	
	int first;
	int second;
	String op;
	
	public String addSymbol(String s)
	{
		if (s.equalsIgnoreCase("+") == true)
		{
			op = s;
			return "";
		}
		else if (s.equalsIgnoreCase("-") == true)
		{
			op = s;
			return "";
		}
		else if (s.equalsIgnoreCase("=") == true)
		{
			if (op.equalsIgnoreCase("+"))
			{
				return first+second+"";
			}
			else if (op.equalsIgnoreCase("-"))
			{
				return first-second+"";
			}
		}
		else
		{
			return "---";
		}
		return "";

	}
	
	public CalculatorLogic()
	{
		firstNum = false;
		opSymbol = false;
		secondNum = false;
		first = 0;
		second = 0;
		op = "";
	}
	
}

 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

import java.awt.*;

import javax.swing.*;

import java.awt.event.*;

public class CalculatorExterior extends JFrame
implements ActionListener
{
	CalculatorLogic cl;
	JPanel mainPanel;
	JPanel bottomPanel;
	JButton[] buttons;
	JTextField resultField;
	String[] buttonLabels = {"0","1","2","3","4",
	                     	 "5", "6", "7", "8", "9",
	                     	 "+", "-", "=", "CLEAR", ""};
	
	private void buildGUI()
	{
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setSize(600, 600);
		setTitle("Calculator");
		
		mainPanel = new JPanel();
		bottomPanel = new JPanel();
		this.setLayout(new GridLayout(2,1));
			
		this.add(mainPanel);
		this.add(bottomPanel);
		
		mainPanel.setLayout(new GridLayout(0,5));
		for (int i = 0; i < 15; i++)
		{
			buttons[i] = new JButton(buttonLabels[i]);
			buttons[i].addActionListener(this);
			
			mainPanel.add(buttons[i]);
		}
		bottomPanel.setLayout(new GridLayout(0,1));
		resultField = new JTextField(40);
		bottomPanel.add(resultField);
		
		setVisible(true);
	}
	
	public CalculatorExterior()
	{
		cl = new CalculatorLogic();
		buttons = new JButton[15];
		buildGUI();
	}

	@Override
	public void actionPerformed(ActionEvent e) 
	{
		JButton btn = (JButton)e.getSource();
		//System.out.println("Button pushed "+btn.getText());
		if (btn == buttons[13]) // clear button
		{
			resultField.setText("0");
		}
		else
		{
			String result = cl.addSymbol(btn.getText());
			resultField.setText(result);
		}
	}

}

1
2
3
4
5
6
7
8
9

public class Test {

	public static void main(String[] args) {
		
		CalculatorExterior ce = new CalculatorExterior();

	}

}

 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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

/*
   img의 전체 픽셀중 noise_ratio 퍼센트 만큼의
   픽셀을 salt & pepper noise로 바꾼다.
*/
void addSaltAndPepperNoise(Mat& img, double noise_ratio)
{
	int rows = img.rows;
	int cols = img.cols;
	int ch = img.channels();
	int num_of_noise_pixels = (int)((double)(rows * cols * ch)*noise_ratio);
	
	for (int i = 0; i < num_of_noise_pixels; i++)
	{
		int r = rand() % rows;  // noise로 바꿀 행을 임의로 선택
		int c = rand() % cols;  // noise로 바꿀 열을 임의로 선택
		int _ch = rand() % ch;  // noise로 바꿀 채널의 임의로 선택

		// img.ptr<uchar>(r)은 r번째 행의 첫번째 픽셀, 첫번째 채널에 대한 주소값을 반환한다.
		uchar* pixel = img.ptr<uchar>(r) +(c*ch) + _ch; // noise로 바꿀 정확한 위치를 계산

		*pixel = (rand() % 2 == 1) ? 255 : 0; // black(0) 혹은 white(255)로 교체
	}
}

int main(int argc, char** argv)
{

	if (argc != 2)
	{
		cout << " Provide image name to read" << endl;
		return -1;
	}

	Mat inputImg;
	Mat spImg;

	inputImg = imread(argv[1], CV_LOAD_IMAGE_COLOR);
	resize(inputImg, inputImg, Size(), 0.3, 0.3, CV_INTER_AREA);

	spImg = inputImg.clone();
	addSaltAndPepperNoise(spImg, 0.05);

	namedWindow("Original", CV_WINDOW_AUTOSIZE);
	namedWindow("SaltAndPepper", CV_WINDOW_AUTOSIZE);


	moveWindow("Original", 100, 100);
	moveWindow("SaltAndPepper", 120, 120);


	imshow("Original", inputImg);
	imshow("SaltAndPepper", spImg);

	waitKey(0);
	return 0;
}

 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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int argc, char** argv)
{

	if (argc != 2)
	{
		cout << " Provide image name to read" << endl;
		return -1;
	}

	Mat inputImg;

	inputImg = imread(argv[1], CV_LOAD_IMAGE_COLOR);
	resize(inputImg, inputImg, Size(), 0.3, 0.3, CV_INTER_AREA);

	Mat noise_image(inputImg.size(), CV_16SC3);
	double average = 0.0;
	double std = 30.0;
	randn(noise_image, Scalar::all(average), Scalar::all(std));

	Mat temp_image;
	inputImg.convertTo(temp_image, CV_16SC3);
	addWeighted(temp_image, 1.0, noise_image, 1.0, 0.0, temp_image);
	temp_image.convertTo(temp_image, inputImg.type());

	
	namedWindow("Original", CV_WINDOW_AUTOSIZE);
	namedWindow("GaussianNoise", CV_WINDOW_AUTOSIZE);


	moveWindow("Original", 100, 100);
	moveWindow("GaussianNoise", 120, 120);


	imshow("Original", inputImg);
	imshow("GaussianNoise", temp_image);

	waitKey(0);
	return 0;
}

 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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int argc, char** argv)
{

	if (argc != 2)
	{
		cout << " Provide image name to read" << endl;
		return -1;
	}

	Mat inputImg;
	Mat hlsImg;
	Mat skinImg;

	inputImg = imread(argv[1], CV_LOAD_IMAGE_COLOR);
	//resize(inputImg, inputImg, Size(), 0.4, 0.4, CV_INTER_AREA);
	skinImg = inputImg.clone();

	cvtColor(inputImg, hlsImg, CV_BGR2HLS);
	vector<Mat> hls_images(3);
	split(hlsImg, hls_images);

	for (int row = 0; row < hlsImg.rows; row++)
	{
		for (int col = 0; col < hlsImg.cols; col++)
		{
			uchar H = hlsImg.at<Vec3b>(row, col)[0];
			uchar L = hlsImg.at<Vec3b>(row, col)[1];
			uchar S = hlsImg.at<Vec3b>(row, col)[2];

			double LS_ratio = ((double)L) / ((double)S);
			bool skin_pixel = (S >= 50) && (LS_ratio > 0.5) && (LS_ratio < 3.0) && ((H <= 14) || (H >= 165));

			if (skin_pixel == false)
			{
				skinImg.at<Vec3b>(row, col)[0] = 0;
				skinImg.at<Vec3b>(row, col)[1] = 0;
				skinImg.at<Vec3b>(row, col)[2] = 0;
			}
		}
	}

	namedWindow("Original", CV_WINDOW_AUTOSIZE);
	namedWindow("SkinDetected", CV_WINDOW_AUTOSIZE);


	moveWindow("Original", 100, 100);
	moveWindow("SkinDetected", 120, 120);


	imshow("Original", inputImg);
	imshow("SkinDetected", skinImg);

	waitKey(0);
	return 0;
}

  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

#include <stdio.h>
#include <stdlib.h>  // malloc

struct node
{
    int data;
    struct node *next;
};
struct node *head = 0;

// SLL에 추가하는 함수
void addToSLL(int _data)
{
    struct node *cur;
    cur = (struct node *)malloc(sizeof(struct node));
    cur->data = _data;
    cur->next = 0;

    //1. SLL이 empty
    if (head == 0)
    {
        head = cur;
        return;
    }
    //2. else
    // 2.1 끝을 찾자
    // 2.2 끝에 붙이자.
    {
        struct node *lastNode = head;
        while (lastNode->next != 0)
        {
            lastNode = lastNode->next;
        }
        lastNode->next = cur;
        return;
    }
}

// SLL에 삽입하는 함수
// where을 찾아서, 그 뒤에 what을 추가
// where가 없으면, 맨앞에 what을 추가
void insertToSLL(int where, int what)
{
    // 1. where를 찾자
    struct node *wp = head;
    while (1)
    {
        if (wp == 0)
        {
            break;
        }
        if (wp->data == where)
        {
            break;
        }
        wp = wp->next;
    }
    {
        struct node *cur;  // 새로 추가할 노드
        cur = (struct node *)malloc(sizeof(struct node));
        cur->data = what;
        cur->next = 0;

        if (wp == 0)  // where를 가진 노드가 없으므로, 맨앞에 추가
        {
            cur->next = head;
            head = cur;
            return;
        }
        else  // where를 찾았으므로, 그 뒤에 추가
        {
            cur->next = wp->next;
            wp->next = cur;
            return;
        }
    }
}

// _data를 찾아서 삭제
void delFromSLL(int _data)
{
    struct node *cur = head;

    while (1)
    {
        if (cur == 0)
        {
            break;
        }
        if (cur->data == _data)
        {
            break;
        }
        cur = cur->next;
    }

    if (cur == 0)  // 지울 것을 못 찾았음.
    {
        return;
    }
    {
        //1. 맨앞의 것을 가리키는 경우
        if (cur == head)
        {
            head = head->next;
            free(cur);
            return;
        }
        else
        {
            struct node *prev = head;
            while (prev->next != cur)
            {
                prev = prev->next;
            }
            prev->next = cur->next;
            free(cur);
            return;
        }
    }
}

void destroyReverse()
{
    struct node *cur;
    while (1)
    {
        cur = head;
        if (head->next == 0)  // 노드가 하나 남았을 경우
        {
            free(head);
            head = 0;
            return;
        }
        while (cur->next->next != 0)
        {
            cur = cur->next;
        }
        free(cur->next);
        cur->next = 0;
    }
}

// 완전 삭제
void destroySLL()
{
    struct node *cur = head;

    while (1)
    {
        if (cur == 0)
        {
            return;
        }
        head = head->next;
        free(cur);
        cur = head;

    }
}

// SLL에 들어 있는 데이터를
// 앞에서부터 차례로 출력
void showSLL()
{
    struct node *cur = head;

    while (cur != 0)
    {
        printf("%d-->", cur->data);
        cur = cur->next;
    }
    printf("\n");
    return;
}

int main(void)
{
    int data;
    char op;
    // a 10
    // d 10
    // s 10
    while (1)
    {
        printf("Enter op and data: ");
        scanf(" %c %d", &op, &data);
        switch (op)
        {
        case 'a':
            addToSLL(data);
            break;
        case 'd':
            delFromSLL(data);
            break;
        case 's':
            showSLL();
            break;
        case 'z':
            return 0;
        default:
            break;
        }


    }


    return 0;
}

#if 0
addToSLL(3);
addToSLL(5);
showSLL(); // 3, 5

insertToSLL(3, 10);
showSLL(); // 3, 10, 5

insertToSLL(5, 20);
showSLL(); // 3, 10, 5, 20

insertToSLL(999, 7);
showSLL(); // 7, 3, 10, 5, 20

delFromSLL(7);
delFromSLL(20);
delFromSLL(10);
showSLL(); // 3, 5

destroySLL();
addToSLL(56);
showSLL(); // 56
#endif

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <stdio.h>

int main(void)
{
	int data;

	while (1)
	{
		printf("Enter number: ");
		scanf("%d", &data);

		printf("Data is %d\n", data);
		if (data == -999)
		{
			printf("Program ended\n");
			break;
		}
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include <stdio.h>

int main(void)
{
	char data;

	while (1)
	{
		printf("Enter char: ");
		scanf("%c", &data);

		printf("Data is %c\n", data);
		if (data == 'z')
		{
			printf("Program ended\n");
			break;
		}
	}
}

 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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int argc, char** argv)
{

	if (argc != 2)
	{
		cout << " Provide image name to read" << endl;
		return -1;
	}

	Mat inputImg;
	Mat hlsImg;

	inputImg = imread(argv[1], CV_LOAD_IMAGE_COLOR);

	cvtColor(inputImg, hlsImg, CV_BGR2HLS);
	vector<Mat> hls_images(3);
	split(hlsImg, hls_images);  // H, L, S로 분리하는 부분

	namedWindow("Original", CV_WINDOW_AUTOSIZE);
	namedWindow("H", CV_WINDOW_AUTOSIZE);
	namedWindow("L", CV_WINDOW_AUTOSIZE);
	namedWindow("S", CV_WINDOW_AUTOSIZE);

	moveWindow("Original", 100, 100);
	moveWindow("H", 120, 120);
	moveWindow("L", 140, 140);
	moveWindow("S", 160, 160);

	imshow("Original", inputImg);
	imshow("H", hls_images[0]);
	imshow("L", hls_images[1]);
	imshow("S", hls_images[2]);

	waitKey(0);
	return 0;
}

 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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int argc, char** argv)
{

	if (argc != 2)
	{
		cout << " Provide image name to read" << endl;
		return -1;
	}

	Mat inputImg;
	Mat yuvImg;

	inputImg = imread(argv[1], CV_LOAD_IMAGE_COLOR);

	cvtColor(inputImg, yuvImg, CV_BGR2YUV);
	vector<Mat> yuv_images(3);
	split(yuvImg, yuv_images);

	namedWindow("Original", CV_WINDOW_AUTOSIZE);
	namedWindow("Y", CV_WINDOW_AUTOSIZE);
	namedWindow("U", CV_WINDOW_AUTOSIZE);
	namedWindow("V", CV_WINDOW_AUTOSIZE);

	moveWindow("Original", 100, 100);
	moveWindow("Y", 120, 120);
	moveWindow("U", 140, 140);
	moveWindow("V", 160, 160);

	imshow("Original", inputImg);
	imshow("Y", yuv_images[0]);
	imshow("U", yuv_images[1]);
	imshow("V", yuv_images[2]);

	waitKey(0);
	return 0;
}

 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

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int argc, char** argv)
{

	if (argc != 2)
	{
		cout << " Provide image name to read" << endl;
		return -1;
	}

	Mat inputImg;
	Mat outputImg;

	inputImg = imread(argv[1], CV_LOAD_IMAGE_COLOR);
	outputImg = inputImg.clone();

	const int64 start = getTickCount();

	int image_rows = inputImg.rows;
	int image_cols = inputImg.cols;

//#define USE_AT
#ifdef USE_AT
	for (int r = 0; r < image_rows; r++)
	{
		for (int c = 0; c < image_cols; c++)
		{
			for (int ch = 0; ch < 3; ch++)
			{
				outputImg.at<Vec3b>(r, c)[ch] = 255 - outputImg.at<Vec3b>(r, c)[ch];
			}
		}
	}
#else if
	for (int r = 0; r < image_rows; r++)
	{
		uchar* value = inputImg.ptr<uchar>(r);
		uchar* result = outputImg.ptr<uchar>(r);
		for (int c = 0; c < image_cols; c++)
		{
			*result++ = *value++ ^ 0xff;
			*result++ = *value++ ^ 0xff;
			*result++ = *value++ ^ 0xff;
		}
	}
#endif
	int64 elapsed = (getTickCount() - start);

	cout << "Elapsed time " << elapsed << endl;

	namedWindow("input", CV_WINDOW_AUTOSIZE);
	namedWindow("output", CV_WINDOW_AUTOSIZE);
	moveWindow("input", 100, 100);
	moveWindow("output", 120, 120);
	imshow("input", inputImg);
	imshow("output", outputImg);

	waitKey(0);
	return 0;
}