بایگانی برچسب برای: hk

انواع رزولوشن در دوربین های مدار بسته

در دوربین های مداربسته ی آنالوگ، رزولوشن با TV Line اندازه گیری می شود. در اکثر دوربین های آنالوگ جدید، TVL بین 420 تا 700 متغیر است. اگر چه 420TVL پایین ترین محسوب می شود، سیستم های امنیت تصویری وجود دارد که لازم است فقط یک فاصله ی کوتاه پوشش داده شود و در اینگونه موارد دوربین های 420TVL خوب کار می کنند.

دوربین های 600TVL به بالا، تصاویر دقیق تر و کنتراست بالایی دارند. اگر نیاز به تصویر صاف و دقیق دارید، دوربین های بالای 600TVL را انتخاب کنید هر چند فاکتور های مهم دیگری مانند میزان لوکس، WDR و … در تصویر دریافتی از دوربین تاثیر گذار هستند.

وقتی دوربین ها تصاویر را دریافت می کنند، آن را از طریق کابل به DVR می فرستند. در DVR، تصاویر از حالت آنالوگ به حالت دیجیتال تبدیل می شوند تا هم روی هارد ذخیره شوند و هم از طریق مانیتور نمایش داده شوند. این مهمترین بخش زنجیره ی دریافت و ذخیره ی تصاویر در دوربین های مدار بسته است.

بهترین دوربین ها با بالاترین کیفیت هم در صورتی که از یک DVR با توانایی تبدیل پایین استفاده شود نمی تواند تصویر خوبی به شما بدهد. DVR ها دو مدل رزولوشن پرکاربرد دارند : D1 , Cif

Cif سایز 320*240 پیکسل به شما می دهد و D1 سایز 720*480 و همانطور که مشخص است، D1 چهار برابر بزرگتر از Cif است پس تصویر کمتر فشرده می شود و در نتیجه جزئیات بیشتری را نشان می دهد.

برای انتخاب DVR، رزولوشن ضبط تصاویر را در نظر داشته باشید. بعضی از DVR ها هر دو گزینه را دارند ولی معمولا تعداد فریم بر ثانیه را پایین می آورد تا تصاویر پر کیفیت تری ارائه دهد.

 

رزولوشن در دوربین های مدار بسته

 

دوربین های آی پی (IP) قابلیت این را دارند که تصاویر با رزولوشن خیلی خیلی بالاتر داشته باشند. اولین چیزی که باید در مورد دوربین های آی پی بدانید این است که تصاویر را به صورت دیجیتال دریافت می کند به همین خاطر نیازی به تبدیل یا فشرده سازی وجود ندارد. دومین مسئله این است که دوربین های آی پی تصاویر را از طریق کابل های Ca45 یا Ca46 منتقل می کند که قابلیت گذردهی خیلی بیشتری دارند.

دوربین های 1.3 مگاپیکسل معمولا کوچکترین رزولوشن دوربین های آی پی است( البته رزولوشن های پایین تر هم وجود دارد) که خیلی خیلی بزرگتر و با کیفیت تر از هر دوربین آنالوگ دیگری است.

با این وجود اگر حتی تصاویر 1280*1024 پیکسل هم برایتان کوچک است می توانید از دوربین های 3 مگا پیکسل که رزولوشن 2048*1536 پیکسل دارند استفاده کنید یا حتی اگر این هم کم است می توانید دوربین های 5 مگا پیکسل (1944*2592) استفاده کنید.

خلاصه اینکه با دوربین های آنالوگ و استفاده از DVR شما نهایت تصاویر D1, 4Cif, 2Cif ,Cif خواهید داشت که ممکن است بتوانند نیازهای شما را برآورده کنند. ولی اگر نیاز به رزولوشن بالاتری دارید باید دوربین های آی پی را در نظر بگیرید و از آنها استفاده کنید.

 

منبع : http://www.elmcctv.ir

 

/0 دیدگاه /توسط

تکنولوژی EFFIO-A و EFFIO-V

تکنولوژی EFFIO-V و EFFIO-A چیست؟

تکنولوژی EFFIO-V و EFFIO-A که توسط شرکت سونی به بازار عرضه شده اند با قابلیت و عملکردهای بسیار توسعه یافته به عنوان نسل سوم سری EFFIO در نظر گرفته می شود.

این دو محصول جدید میتوانند با سنسور تصویر 960H ترکیب شده تا بتوانند کیفیت تصویری بالاتر از 700 تی وی لاین را ایجاد نماید. همچنین این آی سی ها بهبود یافتند تا قابلیت هایی از قبیل کاهش نویز سه بعدی (3D-NR)و قرار گرفتن در معرض مادون قرمز و طیف گسترده ای پویا (WDR) و یا مه زدا DEFOG)) و نمایش تصاویر در شرایط مختلف مانند نور کم ، نور مادون قرمز و نور زیاد که کاملا توسعه یافته در عملکرد خود داشته باشند. علاوه بر این این آی سی ها برای اولین بار قابلیت تشخیص اتوماتیک به صورت صنعتی و انتخاب صحنه را دارا هستند.

EFFIO-V و EFFIO-A ، اصلاح شده تا پردازشگر سیگنال را با وضوح بالا انجام دهد و رزولوشن بالای 700تی وی لاین را ایجاد کند که این رزولوشن بالاتر از رزولوشن سری های EFFIOموجود 650 تی وی لاین است .

EFFIO-V و EFFIO-A

قابلیت کاهش نویز سه بعدی

این تکنولوژی تاری موضوعات در حال حرکت ، روشنی و سیگنال به نویز تصاویری که حتی در محیط های کم نور هستند را کاهش می دهد. همچنین به طور موثر از شرایط زمانی که انعکاس نور مادون قرمز بیش از حد شده باشد و یا جزئیات نفر پنهان شده باشد و یا زمانی که در اطراف لبه ای بیرونی تصاویر و یا گوشه های تاریک شده (سایه) باشد جلوگیری می کند.
بنابراین قابلیت این تکنولوژی بهبود بخشیدن تصاویر در محیط های کم نور می باشد.

این محصولات عملکرد مناسب در هر شرایطی برای تنظیم تصاویر را دارا هستند . بعضی از نصب ها زمان زیادی برای تنظیم چند دوربین با ویژگی های مختلف برای کیفیت بهتر را از ما می گیرند . اما EFFIO-V و EFFIO-A قابلیت تشخیص اتوماتیک صحنه را دارند و فقط نیاز به یک عملکرد برای 40الگو در صحنه های تصاویر را برای تصویری ایده آل مثل محدوده دینامیکی ، درجه حرارت ، رنگ را دارد. قابلیت انتخاب صحنه از پیش تنظیم شده برای صحنه های عمومی از جمله دوربین های محیط داخل و محیط خارج نصب شده یا نظارت ترافیکی و یا نور پس زمینه تنظیمات اتوماتیک آنها بر پایه تنظیمات برای کیفیت تصویر ایده آل می باشد .

این قابلیت تنظیمات اتوماتیک برای آسان تر شدن نصب و راه اندازی تصاویر با کیفیت است .

 

EFFIO-V و EFFIO-A

 

 

 

استفاده از EFFIO-V و EFFIO-A

استفاده از EFFIO-V و EFFIO-A

 

 

تاری در سایر ccd ها

سایر ccd ها

 

 

منبع

 
Item Effio-V Effio-A
Supported CCDs 760 H, 960 H WDR/normal CCD 760 H, 960 H normal CCD
 

 

 

 

 

 

 

 

 

 

Functions

 Resolution Horizontal over 700 TV lines ←
WDR ✔ —
ATR-EX2 ✔ ←
Noise reduction 2D-NR, 3D-NR ←
Day & Night ✔ ←
Polygon privacy mask Up to 20 masks ←
E-zoom ✔ ←
Slow shutter ✔ ←
Digital image stabilizer ✔ ←
BLC/HLC ✔ ←
Automatic scene detection function ✔ ←
Scene selection function ✔ ←
AF detector ✔ ←
Motion detection ✔ ←
White pixel detection compensation Static and dynamic ←
OSD Flexible 8 languages ←
Lens shading compensation ✔ ←
Defog ✔ ←
Automatic mechanical iris adjustment ✔ ←
External synchronization LL, VSL ←
RS-485 ✔ ←
Coaxial communication ✔ (Coaxitron by Pelco) ←
Outputs Analog outputs Y/C separate, composite ←
Digital outputs ITU-R BT.656 compliant
(27 MHz / 36 MHz)		 ←
Package 97-pin LFBGA ←
/0 دیدگاه /توسط

تبدیل فضای رنگی به یک دیگر

,

چرا از فضای رنگی مختلف استفاده می کنیم؟

از فضای رنگی مختلف استفاده می کنیم چون این امکان در آن فضای رنگی به ما داده میشه تا بتوینم رنگ دلخواه مان را به راحتی از محدوده دیگر رنگ ها جدا کنیم .فرض کنید که شما قصد دارید رنگ سبز را در تصویر فیلتر نمایید این بازه شامل طیفی می باشد که یک سمت آن سبز تیره و در سمت دیگر آن سبز روشن می باشد برای جدا کردن آن در فضای رنگی RGB این امکان وجود ندارد که شما بتوان به صورت خطی یعنی هر کانال با یک شرط بازه رنگ دلخواه را انتخاب نمائید پس به خاطر چنین مشکلاتی تصویر را به فضای رنگی HSV انتقال می دهیم که این فضا از اجزای Hue (رنگدانه) ،Saturation(اشباع) و Value(روشنایی) تشکیل شده.برای تفکیک رنگ سبز در این فضای رنگی کافیست محدوده Hue خود که مربوط به رنگ مورد نظر را انتخاب کرده و سپس کل محدوه اشباع و در نهایت انتخاب محدوده دلخواه برای روشنایی پس در این فضای رنگی به راحتی تونستید رنگ دلخواه خودتون را انتخاب کنید.

تبدیل فضای رنگی در opencv

در کتابخانه Opencv می تونیم از تابع cvtColor استفاده کنیم.

مثال:

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
/*------------------------------------------------------------------------------------------*\
This file contains material supporting chapter 3 of the cookbook:
Computer Vision Programming using the OpenCV Library
Second Edition
by Robert Laganiere, Packt Publishing, 2013.
 
This program is free software; permission is hereby granted to use, copy, modify,
and distribute this source code, or portions thereof, for any purpose, without fee,
subject to the restriction that the copyright notice may not be removed
or altered from any source or altered source distribution.
The software is released on an as-is basis and without any warranties of any kind.
In particular, the software is not guaranteed to be fault-tolerant or free from failure.
The author disclaims all warranties with regard to this software, any use,
and any consequent failure, is purely the responsibility of the user.
 
Copyright (C) 2013 Robert Laganiere, www.laganiere.name
\*------------------------------------------------------------------------------------------*/
 
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
 
#include <iostream>
#include <vector>
 
void detectHScolor(const cv::Mat& image, // input image
double minHue, double maxHue, // Hue interval
double minSat, double maxSat, // saturation interval
cv::Mat& mask) { // output mask
 
// convert into HSV space
cv::Mat hsv;
cv::cvtColor(image, hsv, CV_BGR2HSV);
 
// split the 3 channels into 3 images
std::vector<cv::Mat> channels;
cv::split(hsv, channels);
// channels[0] is the Hue
// channels[1] is the Saturation
// channels[2] is the Value
 
// Hue masking
cv::Mat mask1; // under maxHue
cv::threshold(channels[0], mask1, maxHue, 255, cv::THRESH_BINARY_INV);
cv::Mat mask2; // over minHue
cv::threshold(channels[0], mask2, minHue, 255, cv::THRESH_BINARY);
 
cv::Mat hueMask; // hue mask
if (minHue < maxHue)
hueMask = mask1 & mask2;
else // if interval crosses the zero-degree axis
hueMask = mask1 | mask2;
 
// Saturation masking
// under maxSat
cv::threshold(channels[1], mask1, maxSat, 255, cv::THRESH_BINARY_INV);
// over minSat
cv::threshold(channels[1], mask2, minSat, 255, cv::THRESH_BINARY);
 
cv::Mat satMask; // saturation mask
satMask = mask1 & mask2;
 
// combined mask
mask = hueMask&satMask;
}
 
int main()
{
// read the image
cv::Mat image= cv::imread("boldt.jpg");
if (!image.data)
return 0;
 
// show original image
cv::namedWindow("Original image");
cv::imshow("Original image",image);
 
// convert into HSV space
cv::Mat hsv;
cv::cvtColor(image, hsv, CV_BGR2HSV);
 
// split the 3 channels into 3 images
std::vector<cv::Mat> channels;
cv::split(hsv,channels);
// channels[0] is the Hue
// channels[1] is the Saturation
// channels[2] is the Value
 
// display value
cv::namedWindow("Value");
cv::imshow("Value",channels[2]);
 
// display saturation
cv::namedWindow("Saturation");
cv::imshow("Saturation",channels[1]);
 
// display hue
cv::namedWindow("Hue");
cv::imshow("Hue",channels[0]);
 
// image with fixed value
cv::Mat newImage;
cv::Mat tmp(channels[2].clone());
// Value channel will be 255 for all pixels
channels[2]= 255;
// merge back the channels
cv::merge(channels,hsv);
// re-convert to BGR
cv::cvtColor(hsv,newImage,CV_HSV2BGR);
 
cv::namedWindow("Fixed Value Image");
cv::imshow("Fixed Value Image",newImage);
 
// image with fixed saturation
channels[1]= 255;
channels[2]= tmp;
cv::merge(channels,hsv);
cv::cvtColor(hsv,newImage,CV_HSV2BGR);
 
cv::namedWindow("Fixed saturation");
cv::imshow("Fixed saturation",newImage);
 
// image with fixed value and fixed saturation
channels[1]= 255;
channels[2]= 255;
cv::merge(channels,hsv);
cv::cvtColor(hsv,newImage,CV_HSV2BGR);
 
cv::namedWindow("Fixed saturation/value");
cv::imshow("Fixed saturation/value",newImage);
 
// Testing skin detection
 
// read the image
image= cv::imread("girl.jpg");
if (!image.data)
return 0;
 
// show original image
cv::namedWindow("Original image");
cv::imshow("Original image",image);
 
// detect skin tone
cv::Mat mask;
detectHScolor(image,
160, 10, // hue from 320 degrees to 20 degrees
25, 166, // saturation from ~0.1 to 0.65
mask);
 
// show masked image
cv::Mat detected(image.size(), CV_8UC3, cv::Scalar(0, 0, 0));
image.copyTo(detected, mask);
cv::imshow("Detection result",detected);
 
// A test comparing luminance and brightness
 
// create linear intensity image
cv::Mat linear(100,256,CV_8U);
for (int i=0; i<256; i++) {
 
linear.col(i)= i;
}
 
// create a Lab image
linear.copyTo(channels[0]);
cv::Mat constante(100,256,CV_8U,cv::Scalar(128));
constante.copyTo(channels[1]);
constante.copyTo(channels[2]);
cv::merge(channels,image);
 
// convert back to BGR
cv::Mat brightness;
cv::cvtColor(image,brightness, CV_Lab2BGR);
cv::split(brightness, channels);
 
// create combined image
cv::Mat combined(200,256, CV_8U);
cv::Mat half1(combined,cv::Rect(0,0,256,100));
linear.copyTo(half1);
cv::Mat half2(combined,cv::Rect(0,100,256,100));
channels[0].copyTo(half2);
 
cv::namedWindow("Luminance vs Brightness");
cv::imshow("Luminance vs Brightness",combined);
 
cv::waitKey();
}

منبع

/0 دیدگاه /توسط

رباتیک چیست؟ قسمت 2

مهندسی رباتیک چیست ؟

مهندسی رباتیک چیست ؟

ربات چيست؟

ربات يك ماشين الكترومكانيكي هوشمند است با خصوصيات زير:
– مي توان آن را مكرراً برنامه ريزي كرد.
– چند كاره است.
– كارآمد و مناسب براي محيط است.

اجزاي يك ربات

– وسايل مكانيكي و الكتريكي:
شاسي، موتورها، منبع تغذيه، …
– حسگرها (براي شناسايي محيط):
دوربين ها، سنسورهاي sonar، سنسورهاي ultrasound، …
– عملكردها (براي انجام اعمال لازم)
بازوي روبات، چرخها، پاها، …
– قسمت تصميم گيري (برنامه اي براي تعيين اعمال لازم):
حركت در يك جهت خاص، دوري از موانع، برداشتن اجسام، …
– قسمت كنترل (براي راه اندازي و بررسي حركات روبات):
نيروها و گشتاورهاي موتورها براي سرعت مورد نظر، جهت مورد نظر، كنترل مسير، ..

تاريخچه رباتيك:

– 270 ق م : زماني كه يونانيان به ساخت مجسمه هاي متحرك ميپرداختند.
– حدود سال 1250 م: بيشاپ آلبرتوس ماگنوس (Bishop Albertus Magnus) ضيافتي ترتيب داد كه درآن، ميزبانان آهني از مهمانان پذيرايي مي كردند. با ديدن اين روبات، سنت توماس آكويناس (Thomas Aquinas) برآشفته شد، ميزبان آهني را تكه تكه كرد و بيشاب را ساحر و جادوگر خواند.
– سال 1640 م: دكارت ماشين خودكاري به صورت يك خانم ساخت و آن را Ma fille Francine ” مي ناميد.اين ماشين كه دكارت را در يك سفر دريايي همراهي مي كرد، توسط كاپيتان كشتي به آب پرتاب شد چرا كه وي تصور مي كرد اين موجود ساخته شيطان است.
– سال 1738 م: ژاك دواكانسن (Jacques de Vaucanson) يك اردك مكانيكي ساخت كه از بيش از 4000 قطعه تشكيل شده بود. اين اردك مي توانست از خود صدا توليد كند، شنا كند، آب بنوشد، دانه بخورد و آن را هضم و سپس دفع كند. امروزه در مورد محل نگهداري اين اردك اطلاعي در دست نيست.
– سال 1805 م: عروسكي توسط ميلاردت (Maillardet) ساخته شد كه مي توانست به زبان انگليسي و فرانسوي بنويسد و مناظري را نقاشي كند.
– سال 1923 م: كارل چاپك (Karel Capek) براي اولين بار از كلمه روبات (robot) در نمايشنامه خود به عنوان آدم مصنوعي استفاده كرد. كلمه روبات از كلمه چك robota گرفته شده است كه به معني برده و كارگر مزدور است. موضوع نمايشنامه چاپك، كنترل انسانها توسط روباتها بود، ولي او هرگونه امكان جايگزيني انسان با روبات و يا اينكه روباتها از احساس برخوردار شوند، عاشق شوند، يا تنفر پيدا كنند را رد مي كرد.
– سال 1940 م: شركت وستينگهاوس (Westinghouse Co.) سگي به نام اسپاركو (Sparko) ساخت كه هم از قطعات مكانيكي و هم الكتريكي در ساخب آن استفاده شده بود. اين اولين باري بود كه از قطعات الكتريكي نيز همراه با قطعات مكانيكي استفاده مي شد.
– سال 1942 م: كلمه روباتيك (robatics) اولين بار توسط ايزاك آسيموف در يك داستان كوتاه ارائه شد. ايزاك آسيموف (1920-1992) نويسنده كتابهاي توصيفي درباره علوم و داستانهاي علمي تخيلي است.
– دهه 1950 م: تكنولوژي كامپيوتر پيشرفت كرد و صنعت كنترل متحول شد. سؤلاتي مطرح شدند. مثلاً: آيا كامپيوتر يك روبات غير متحرك است؟
– سال 1954 م: عصر روبات ها با ارائه اولين روبات آدم نما توسط جرج دوول (George Devol) شروع شد.
– سال 1956 م: پس از توسعه فعاليتهاي تكنولوژي يك كه بعد از جنگ جهاني دوم، يك ملاقات تاريخي بين جورج سي.دوول(George C.Devol) مخترع و كارآفرين صاحب نام، و ژوزف اف.انگلبرگر (Joseph F.Engelberger) كه يك مهندس با سابقه بود، صورت گرفت. در اين ملاقات آنها به بحث در مورد داستان آسيموف پرداختند. ايشان سپس به موفقيتهاي اساسي در توليد روباتها دست يافتند و با تأسيس شركتهاي تجاري، به توليد روبات مشغول شدند. انگلبرگر شركت Unimate برگرفته از Universal Automation را براي توليد روبات پايه گذاري كرد. نخستين روباتهاي اين شركت در كارخانه جنرال موتورز (General Motors) براي انجام كارهاي دشوار در خودروسازي به كار گرفته شد. انگلبرگر را “پدر روباتيك” ناميده اند.
– دهه 1960 م: روباتهاي صنعتي زيادي ساخته شدند. انجمن صنايع روباتيك اين تعريف را براي روبات صنعتي ارائه كرد:
“روبات صنعتي يك وسيلة چند كاره و با قابليت برنامه ريزي چند باره است كه براي جابجايي قطعات، مواد، ابزارها يا وسايل خاص بوسيلة حركات برنامه ريزي شده، براي انجام كارهاي متنوع استفاده مي شود.”
– سال 1962 م: شركت خودروسازي جنرال موتورز نخستين روبات Unimate را در خط مونتاژ خود به كار گرفت.
– سال 1967 م: رالف موزر (Ralph Moser) از شركت جنرال الكتريك (General Electeric) نخستين روبات چهارپا را اختراع كرد.
– سال 1983 م: شركت Odetics يك روبات شش پا ارائه كرد كه مي توانست از موانع عبور كند و بارهاي سنگيني را نيز با خود حمل كند.
– سال 1985 م: نخستين روباتي كه به تنهايي توانايي راه رفتن داشت در دانشگاه ايالتي اهايو (Ohio State Uneversity) ساخته شد.
– سال 1996 م: شركت ژاپني هندا (Honda) نخستين روبات انسان نما را ارائه كرد كه با دو دست و دو پا طوري طراحي شده بود كه مي توانست راه برود، از پله بالا برود، روي صندلي بنشيند و بلند شود و بارهايي به وزن 5 كيلوگرم را حمل كند
روباتها روز به روز هوشمندتر مي شوند تا هرچه بيشتر در كارهاي سخت و پر خطر به ياري انسانها بيايند.
امروزه، 90% روباتها، روباتهاي صنعتي هستند، يعني روباتهايي كه در كارخانه ها، آزمايشگاهها، انبارها، نيروگاهها، بيمارستانها، و بخشهاي مشابه به كارگرفته مي شوند.در سالهاي قبل، اكثر روباتهاي صنعتي در كارخانه هاي خودروسازي به كارگرفته مي شدند، ولي امروزه تنها حدود نيمي از روباتهاي موجود در دنيا در كارخانه هاي خودروسازي به كار گرفته مي شوند.مصارف روباتها در همه ابعاد زندگي انسان به سرعت در حال گسترش است تا كارهاي سخت و خطرناك را به جاي انسان انجام دهند.براي مثال امروزه براي بررسي وضعيت داخلي رآكتورها از روبات استفاده مي شود تا تشعشعات راديواكتيو به انسانها صدمه نزند.

3 قانون روباتيك مطرح شده توسط آسيموف:

1- روبات ها نبايد هيچگاه به انسانها صدمه بزنند.
2- روباتهابايد دستورات انسانها را بدون سرپيجي از قانون اوّل اجرا كنند.
3- روباتها بايد بدون نقض قانون اوّل و دوم از خود محافظت كنند.

انواع ربات ها :

رباتهاي امروزي كه شامل قطعات الكترونيكي و مكانيكي هستند در ابتدا به صورت بازوهاي مكانيكي براي جابجايي قطعات و يا كارهاي ساده و تكراري كه موجب خستگي و عدم تمركز كارگر و افت بازده ميشد بوجود آمدند. اينگونه رباتها جابجاگر (manipulator) نام دارند. جابجاگرها معمولا در نقطه ثابت و در فضاي كاملا كنترل شده در كارخانه نصب ميشوند و به غير از وظيفه اي كه به خاطر آن طراحي شده اند قادر به انجام كار ديگري نيستند. اين وظيفه ميتواند در حد بسته بندي توليدات, كنترل كيفيت و جدا كردن توليدات بي كيفيت, و يا كارهاي پيچيده تري همچون جوشكاري و رنگزني با دقت بالا باشد.
نوع ديگر رباتها كه امروزه مورد توجه بيشتري است رباتهاي متحرك هستند كه مانند رباتهاي جابجا كننده در محيط ثابت و شرايط كنترل شده كار نميكنند. بلكه همانند موجودات زنده در دنياي واقعي و با شرايط واقعي زندگي ميكنند و سير اتفاقاتي كه ربات بايد با انها روبرو شود از قبل مشخص نيست. در اين نوع ربات هاست كه تكنيك هاي هوش مصنوعي ميبايست در كنترلر ربات(مغز ربات) به كار گرفته شود.

رباتهاي متحرك به دسته هاي زير تقسيم بندي ميشوند:

1-رباتهاي چرخ دار
با انواع چرخ عادي
و يا شني تانك
و با پيكربندي هاي مختلف يك, دو يا چند قسمتي
2-رباتهاي پادار مثل سگ اسباب بازيAIBO ساخت سوني كه در شكل بالا نشان داده شد يا ربات ASIMO ساخت شركت هوندا
3-رباتهاي پرنده
4-رباتهاي چند گانه(هايبريد) كه تركيبي از رباتهاي بالا يا تركيب با جابجاگرها هستند
و …

مزاياي روباتها:

1- روباتيك و اتوماسيون در بسياري از موارد مي توانند ايمني، ميزان توليد، بهره و كيفيت محصولات را افزايش دهند.
2- روباتها مي توانند در موقعيت هاي خطرناك كار كنند و با اين كار جان هزاران انسان را نجات دهند.
3- روباتها به راحتي محيط اطراف خود توجه ندارند و نيازهاي انساني براي آنها مفهومي ندارد. روباتها هيچگاه خسته نمي شوند.
4- دقت روباتها خيلي بيشتر از انسانها است آنها در حد ميلي يا حتي ميكرو اينچ دقت دارند.
5- روباتها مي توانند در يك لحظه چند كار را با هم انجام دهند ولي انسانها در يك لحظه تنها يك كار انجام مي دهند.

معايب روباتها:

1- روباتها در موقعيتهاي اضطراري توانايي پاسخگويي مناسب ندارند كه اين مطلب مي تواند بسيار خطرناك باشد.
2- روباتها هزينه بر هستند.
3- قابليت هاي محدود دارند يعني فقط كاري كه براي آن ساخته شده اند را انجام مي دهند.

 

منبع

 

کلمه ربات توسط Karel Capek نویسنده نمایشنامه ( R.U.R  عقل ربات های جهانی) در سال 1920 ابداع شد. ریشه این کلمه، کلمه چک اسلواکی (robotnic) به معنی کارگر می‌باشد.

رباتیک چیست

 

 

منابع

1.fa.wikipedia.org

2. www.enline.ir

3.http://rasekhoon.net

4.http://mediasoft.ir

رباتیک چیست؟ قسمت 1
رباتیک چیست؟ قسمت 2

/0 دیدگاه /توسط

الگوریتم Canny در سی پلاس پلاس قسمت 4

 

مرحله 4: سرکوب لبه های غیر حداکثر

آخرین مرحله، پیدا کردن لبه های ضعیف که موازی با لبه های قوی هستند و از بین بردن آنهاست. این عمل، با بررسی پیکسل های عمود بر یک پیکسل لبه خاص و حذف لبه های غیر حداکثرانجام شده است. کد مورد استفاده بسیار مشابه کد ردیابی لبه است.

 

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
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
</pre>
<pre>#include "stdafx.h"
#include "tripod.h"
#include "tripodDlg.h"
 
#include "LVServerDefs.h"
#include "math.h"
#include <fstream>
#include <string>
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
 
 
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
 
using namespace std;
 
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About
 
class CAboutDlg : public CDialog
{
public:
    CAboutDlg();
 
// Dialog Data
    //{{AFX_DATA(CAboutDlg)
    enum { IDD = IDD_ABOUTBOX };
    //}}AFX_DATA
 
    // ClassWizard generated virtual function overrides
    //{{AFX_VIRTUAL(CAboutDlg)
    protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
    //}}AFX_VIRTUAL
 
// Implementation
protected:
    //{{AFX_MSG(CAboutDlg)
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
};
 
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
    //{{AFX_DATA_INIT(CAboutDlg)
    //}}AFX_DATA_INIT
}
 
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(CAboutDlg)
    //}}AFX_DATA_MAP
}
 
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
    //{{AFX_MSG_MAP(CAboutDlg)
        // No message handlers
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()
 
/////////////////////////////////////////////////////////////////////////////
// CTripodDlg dialog
 
CTripodDlg::CTripodDlg(CWnd* pParent /*=NULL*/)
    : CDialog(CTripodDlg::IDD, pParent)
{
    //{{AFX_DATA_INIT(CTripodDlg)
        // NOTE: the ClassWizard will add member initialization here
    //}}AFX_DATA_INIT
    // Note that LoadIcon does not require a subsequent DestroyIcon in Win32
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
 
    //////////////// Set destination BMP to NULL first
    m_destinationBitmapInfoHeader = NULL;
 
}
 
////////////////////// Additional generic functions
 
static unsigned PixelBytes(int w, int bpp)
{
    return (w * bpp + 7) / 8;
}
 
static unsigned DibRowSize(int w, int bpp)
{
    return (w * bpp + 31) / 32 * 4;
}
 
static unsigned DibRowSize(LPBITMAPINFOHEADER pbi)
{
    return DibRowSize(pbi->biWidth, pbi->biBitCount);
}
 
static unsigned DibRowPadding(int w, int bpp)
{
    return DibRowSize(w, bpp) - PixelBytes(w, bpp);
}
 
static unsigned DibRowPadding(LPBITMAPINFOHEADER pbi)
{
    return DibRowPadding(pbi->biWidth, pbi->biBitCount);
}
 
static unsigned DibImageSize(int w, int h, int bpp)
{
    return h * DibRowSize(w, bpp);
}
 
static size_t DibSize(int w, int h, int bpp)
{
    return sizeof (BITMAPINFOHEADER) + DibImageSize(w, h, bpp);
}
 
/////////////////////// end of generic functions
 
 
void CTripodDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(CTripodDlg)
    DDX_Control(pDX, IDC_PROCESSEDVIEW, m_cVideoProcessedView);
    DDX_Control(pDX, IDC_UNPROCESSEDVIEW, m_cVideoUnprocessedView);
    //}}AFX_DATA_MAP
}
 
BEGIN_MESSAGE_MAP(CTripodDlg, CDialog)
    //{{AFX_MSG_MAP(CTripodDlg)
    ON_WM_SYSCOMMAND()
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    ON_BN_CLICKED(IDEXIT, OnExit)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()
 
/////////////////////////////////////////////////////////////////////////////
// CTripodDlg message handlers
 
BOOL CTripodDlg::OnInitDialog()
{
    CDialog::OnInitDialog();
 
    // Add "About..." menu item to system menu.
 
    // IDM_ABOUTBOX must be in the system command range.
    ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
    ASSERT(IDM_ABOUTBOX < 0xF000);
 
    CMenu* pSysMenu = GetSystemMenu(FALSE);
    if (pSysMenu != NULL)
    {
        CString strAboutMenu;
        strAboutMenu.LoadString(IDS_ABOUTBOX);
        if (!strAboutMenu.IsEmpty())
        {
            pSysMenu->AppendMenu(MF_SEPARATOR);
            pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
        }
    }
 
    // Set the icon for this dialog.  The framework does this automatically
    //  when the application's main window is not a dialog
    SetIcon(m_hIcon, TRUE);         // Set big icon
    SetIcon(m_hIcon, FALSE);        // Set small icon
     
    // TODO: Add extra initialization here
 
    // For Unprocessed view videoportal (top one)
    char sRegUnprocessedView[] = "HKEY_LOCAL_MACHINE\\Software\\UnprocessedView";
    m_cVideoUnprocessedView.PrepareControl("UnprocessedView", sRegUnprocessedView, 0 );
    m_cVideoUnprocessedView.EnableUIElements(UIELEMENT_STATUSBAR,0,TRUE);
    m_cVideoUnprocessedView.ConnectCamera2();
    m_cVideoUnprocessedView.SetEnablePreview(TRUE);
 
    // For binary view videoportal (bottom one)
    char sRegProcessedView[] = "HKEY_LOCAL_MACHINE\\Software\\ProcessedView";
    m_cVideoProcessedView.PrepareControl("ProcessedView", sRegProcessedView, 0 );  
    m_cVideoProcessedView.EnableUIElements(UIELEMENT_STATUSBAR,0,TRUE);
    m_cVideoProcessedView.ConnectCamera2();
    m_cVideoProcessedView.SetEnablePreview(TRUE);
 
    // Initialize the size of binary videoportal
    m_cVideoProcessedView.SetPreviewMaxHeight(240);
    m_cVideoProcessedView.SetPreviewMaxWidth(320);
 
    // Uncomment if you wish to fix the live videoportal's size
    // m_cVideoUnprocessedView.SetPreviewMaxHeight(240);
    // m_cVideoUnprocessedView.SetPreviewMaxWidth(320);
 
    // Find the screen coodinates of the binary videoportal
    m_cVideoProcessedView.GetWindowRect(m_rectForProcessedView);
    ScreenToClient(m_rectForProcessedView);
    allocateDib(CSize(320, 240));
 
    // Start grabbing frame data for Procssed videoportal (bottom one)
    m_cVideoProcessedView.StartVideoHook(0);
 
    return TRUE;  // return TRUE  unless you set the focus to a control
}
 
void CTripodDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
    if ((nID & 0xFFF0) == IDM_ABOUTBOX)
    {
        CAboutDlg dlgAbout;
        dlgAbout.DoModal();
    }
    else
    {
        CDialog::OnSysCommand(nID, lParam);
    }
}
 
// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.
 
void CTripodDlg::OnPaint()
{
    if (IsIconic())
    {
        CPaintDC dc(this); // device context for painting
 
        SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
 
        // Center icon in client rectangle
        int cxIcon = GetSystemMetrics(SM_CXICON);
        int cyIcon = GetSystemMetrics(SM_CYICON);
        CRect rect;
        GetClientRect(&rect);
        int x = (rect.Width() - cxIcon + 1) / 2;
        int y = (rect.Height() - cyIcon + 1) / 2;
 
        // Draw the icon
        dc.DrawIcon(x, y, m_hIcon);
    }
    else
    {
        CDialog::OnPaint();
    }
}
 
// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CTripodDlg::OnQueryDragIcon()
{
    return (HCURSOR) m_hIcon;
}
 
void CTripodDlg::OnExit()
{
    // TODO: Add your control notification handler code here
 
    // Kill live view videoportal (top one)
    m_cVideoUnprocessedView.StopVideoHook(0);
    m_cVideoUnprocessedView.DisconnectCamera();
     
    // Kill binary view videoportal (bottom one)
    m_cVideoProcessedView.StopVideoHook(0);
    m_cVideoProcessedView.DisconnectCamera();  
 
    // Kill program
    DestroyWindow();   
 
     
 
}
 
BEGIN_EVENTSINK_MAP(CTripodDlg, CDialog)
    //{{AFX_EVENTSINK_MAP(CTripodDlg)
    ON_EVENT(CTripodDlg, IDC_PROCESSEDVIEW, 1 /* PortalNotification */, OnPortalNotificationProcessedview, VTS_I4 VTS_I4 VTS_I4 VTS_I4)
    //}}AFX_EVENTSINK_MAP
END_EVENTSINK_MAP()
 
void CTripodDlg::OnPortalNotificationProcessedview(long lMsg, long lParam1, long lParam2, long lParam3)
{
    // TODO: Add your control notification handler code here
     
    // This function is called at the camera's frame rate
     
#define NOTIFICATIONMSG_VIDEOHOOK   10
 
    // Declare some useful variables
    // QCSDKMFC.pdf (Quickcam MFC documentation) p. 103 explains the variables lParam1, lParam2, lParam3 too
     
    LPBITMAPINFOHEADER lpBitmapInfoHeader; // Frame's info header contains info like width and height
    LPBYTE lpBitmapPixelData; // This pointer-to-long will point to the start of the frame's pixel data
    unsigned long lTimeStamp; // Time when frame was grabbed
 
    switch(lMsg) {
        case NOTIFICATIONMSG_VIDEOHOOK:
            {
                lpBitmapInfoHeader = (LPBITMAPINFOHEADER) lParam1;
                lpBitmapPixelData = (LPBYTE) lParam2;
                lTimeStamp = (unsigned long) lParam3;
 
                grayScaleTheFrameData(lpBitmapInfoHeader, lpBitmapPixelData);
                doMyImageProcessing(lpBitmapInfoHeader); // Place where you'd add your image processing code
                displayMyResults(lpBitmapInfoHeader);
 
            }
            break;
 
        default:
            break;
    }  
}
 
void CTripodDlg::allocateDib(CSize sz)
{
    // Purpose: allocate information for a device independent bitmap (DIB)
    // Called from OnInitVideo
 
    if(m_destinationBitmapInfoHeader) {
        free(m_destinationBitmapInfoHeader);
        m_destinationBitmapInfoHeader = NULL;
    }
 
    if(sz.cx | sz.cy) {
        m_destinationBitmapInfoHeader = (LPBITMAPINFOHEADER)malloc(DibSize(sz.cx, sz.cy, 24));
        ASSERT(m_destinationBitmapInfoHeader);
        m_destinationBitmapInfoHeader->biSize = sizeof(BITMAPINFOHEADER);
        m_destinationBitmapInfoHeader->biWidth = sz.cx;
        m_destinationBitmapInfoHeader->biHeight = sz.cy;
        m_destinationBitmapInfoHeader->biPlanes = 1;
        m_destinationBitmapInfoHeader->biBitCount = 24;
        m_destinationBitmapInfoHeader->biCompression = 0;
        m_destinationBitmapInfoHeader->biSizeImage = DibImageSize(sz.cx, sz.cy, 24);
        m_destinationBitmapInfoHeader->biXPelsPerMeter = 0;
        m_destinationBitmapInfoHeader->biYPelsPerMeter = 0;
        m_destinationBitmapInfoHeader->biClrImportant = 0;
        m_destinationBitmapInfoHeader->biClrUsed = 0;
    }
}
 
void CTripodDlg::displayMyResults(LPBITMAPINFOHEADER lpThisBitmapInfoHeader)
{
    // displayMyResults: Displays results of doMyImageProcessing() in the videoport
    // Notes: StretchDIBits stretches a device-independent bitmap to the appropriate size
 
    CDC             *pDC;   // Device context to display bitmap data
     
    pDC = GetDC(); 
    int nOldMode = SetStretchBltMode(pDC->GetSafeHdc(),COLORONCOLOR);
 
    StretchDIBits(
        pDC->GetSafeHdc(),
        m_rectForProcessedView.left,                // videoportal left-most coordinate
        m_rectForProcessedView.top,                 // videoportal top-most coordinate
        m_rectForProcessedView.Width(),             // videoportal width
        m_rectForProcessedView.Height(),            // videoportal height
        0,                                          // Row position to display bitmap in videoportal
        0,                                          // Col position to display bitmap in videoportal
        lpThisBitmapInfoHeader->biWidth,         // m_destinationBmp's number of columns
        lpThisBitmapInfoHeader->biHeight,            // m_destinationBmp's number of rows
        m_destinationBmp,                           // The bitmap to display; use the one resulting from doMyImageProcessing
        (BITMAPINFO*)m_destinationBitmapInfoHeader, // The bitmap's header info e.g. width, height, number of bits etc
        DIB_RGB_COLORS,                             // Use default 24-bit color table
        SRCCOPY                                     // Just display
    );
  
    SetStretchBltMode(pDC->GetSafeHdc(),nOldMode);
 
    ReleaseDC(pDC);
 
    // Note: 04/24/02 - Added the following:
    // Christopher Wagner cwagner@fas.harvard.edu noticed that memory wasn't being freed
 
    // Recall OnPortalNotificationProcessedview, which gets called everytime
    // a frame of data arrives, performs 3 steps:
    // (1) grayScaleTheFrameData - which mallocs m_destinationBmp
    // (2) doMyImageProcesing
    // (3) displayMyResults - which we're in now
    // Since we're finished with the memory we malloc'ed for m_destinationBmp
    // we should free it:
     
    free(m_destinationBmp);
 
    // End of adds
}
 
void CTripodDlg::grayScaleTheFrameData(LPBITMAPINFOHEADER lpThisBitmapInfoHeader, LPBYTE lpThisBitmapPixelData)
{
 
    // grayScaleTheFrameData: Called by CTripodDlg::OnPortalNotificationBinaryview
    // Task: Read current frame pixel data and computes a grayscale version
 
    unsigned int    W, H;             // Width and Height of current frame [pixels]
    BYTE            *sourceBmp;       // Pointer to current frame of data
    unsigned int    row, col;
    unsigned long   i;
    BYTE            grayValue;
 
    BYTE            redValue;
    BYTE            greenValue;
    BYTE            blueValue;
 
    W = lpThisBitmapInfoHeader->biWidth;  // biWidth: number of columns
    H = lpThisBitmapInfoHeader->biHeight; // biHeight: number of rows
 
    // Store pixel data in row-column vector format
    // Recall that each pixel requires 3 bytes (red, blue and green bytes)
    // m_destinationBmp is a protected member and declared in binarizeDlg.h
 
    m_destinationBmp = (BYTE*)malloc(H*3*W*sizeof(BYTE));
 
    // Point to the current frame's pixel data
    sourceBmp = lpThisBitmapPixelData;
 
    for (row = 0; row < H; row++) {
        for (col = 0; col < W; col++) {
 
            // Recall each pixel is composed of 3 bytes
            i = (unsigned long)(row*3*W + 3*col);
         
            // The source pixel has a blue, green andred value:
            blueValue  = *(sourceBmp + i);
            greenValue = *(sourceBmp + i + 1);
            redValue   = *(sourceBmp + i + 2);
 
            // A standard equation for computing a grayscale value based on RGB values
            grayValue = (BYTE)(0.299*redValue + 0.587*greenValue + 0.114*blueValue);
 
            // The destination BMP will be a grayscale version of the source BMP
            *(m_destinationBmp + i)     = grayValue;
            *(m_destinationBmp + i + 1) = grayValue;
            *(m_destinationBmp + i + 2) = grayValue;
             
        }
    }
}
 
 
void CTripodDlg::doMyImageProcessing(LPBITMAPINFOHEADER lpThisBitmapInfoHeader)
{
    // doMyImageProcessing:  This is where you'd write your own image processing code
    // Task: Read a pixel's grayscale value and process accordingly
 
    unsigned int    W, H;           // Width and Height of current frame [pixels]
    unsigned int    row, col;       // Pixel's row and col positions
    unsigned long   i;              // Dummy variable for row-column vector
    int     upperThreshold = 60;    // Gradient strength nessicary to start edge
    int     lowerThreshold = 30;    // Minimum gradient strength to continue edge
    unsigned long iOffset;          // Variable to offset row-column vector during sobel mask
    int rowOffset;                  // Row offset from the current pixel
    int colOffset;                  // Col offset from the current pixel
    int rowTotal = 0;               // Row position of offset pixel
    int colTotal = 0;               // Col position of offset pixel
    int Gx;                         // Sum of Sobel mask products values in the x direction
    int Gy;                         // Sum of Sobel mask products values in the y direction
    float thisAngle;                // Gradient direction based on Gx and Gy
    int newAngle;                   // Approximation of the gradient direction
    bool edgeEnd;                   // Stores whether or not the edge is at the edge of the possible image
    int GxMask[3][3];               // Sobel mask in the x direction
    int GyMask[3][3];               // Sobel mask in the y direction
    int newPixel;                   // Sum pixel values for gaussian
    int gaussianMask[5][5];         // Gaussian mask
 
    W = lpThisBitmapInfoHeader->biWidth;  // biWidth: number of columns
    H = lpThisBitmapInfoHeader->biHeight; // biHeight: number of rows
     
    for (row = 0; row < H; row++) {
        for (col = 0; col < W; col++) {
            edgeDir[row][col] = 0;
        }
    }
 
    /* Declare Sobel masks */
    GxMask[0][0] = -1; GxMask[0][1] = 0; GxMask[0][2] = 1;
    GxMask[1][0] = -2; GxMask[1][1] = 0; GxMask[1][2] = 2;
    GxMask[2][0] = -1; GxMask[2][1] = 0; GxMask[2][2] = 1;
     
    GyMask[0][0] =  1; GyMask[0][1] =  2; GyMask[0][2] =  1;
    GyMask[1][0] =  0; GyMask[1][1] =  0; GyMask[1][2] =  0;
    GyMask[2][0] = -1; GyMask[2][1] = -2; GyMask[2][2] = -1;
 
    /* Declare Gaussian mask */
    gaussianMask[0][0] = 2;     gaussianMask[0][1] = 4;     gaussianMask[0][2] = 5;     gaussianMask[0][3] = 4;     gaussianMask[0][4] = 2;
    gaussianMask[1][0] = 4;     gaussianMask[1][1] = 9;     gaussianMask[1][2] = 12;    gaussianMask[1][3] = 9;     gaussianMask[1][4] = 4;
    gaussianMask[2][0] = 5;     gaussianMask[2][1] = 12;    gaussianMask[2][2] = 15;    gaussianMask[2][3] = 12;    gaussianMask[2][4] = 2;
    gaussianMask[3][0] = 4;     gaussianMask[3][1] = 9;     gaussianMask[3][2] = 12;    gaussianMask[3][3] = 9;     gaussianMask[3][4] = 4;
    gaussianMask[4][0] = 2;     gaussianMask[4][1] = 4;     gaussianMask[4][2] = 5;     gaussianMask[4][3] = 4;     gaussianMask[4][4] = 2;
     
 
    /* Gaussian Blur */
    for (row = 2; row < H-2; row++) {
        for (col = 2; col < W-2; col++) {
            newPixel = 0;
            for (rowOffset=-2; rowOffset<=2; rowOffset++) {
                for (colOffset=-2; colOffset<=2; colOffset++) {
                    rowTotal = row + rowOffset;
                    colTotal = col + colOffset;
                    iOffset = (unsigned long)(rowTotal*3*W + colTotal*3);
                    newPixel += (*(m_destinationBmp + iOffset)) * gaussianMask[2 + rowOffset][2 + colOffset];
                }
            }
            i = (unsigned long)(row*3*W + col*3);
            *(m_destinationBmp + i) = newPixel / 159;
        }
    }
 
    /* Determine edge directions and gradient strengths */
    for (row = 1; row < H-1; row++) {
        for (col = 1; col < W-1; col++) {
            i = (unsigned long)(row*3*W + 3*col);
            Gx = 0;
            Gy = 0;
            /* Calculate the sum of the Sobel mask times the nine surrounding pixels in the x and y direction */
            for (rowOffset=-1; rowOffset<=1; rowOffset++) {
                for (colOffset=-1; colOffset<=1; colOffset++) {
                    rowTotal = row + rowOffset;
                    colTotal = col + colOffset;
                    iOffset = (unsigned long)(rowTotal*3*W + colTotal*3);
                    Gx = Gx + (*(m_destinationBmp + iOffset) * GxMask[rowOffset + 1][colOffset + 1]);
                    Gy = Gy + (*(m_destinationBmp + iOffset) * GyMask[rowOffset + 1][colOffset + 1]);
                }
            }
 
            gradient[row][col] = sqrt(pow(Gx,2.0) + pow(Gy,2.0));   // Calculate gradient strength         
            thisAngle = (atan2(Gx,Gy)/3.14159) * 180.0;     // Calculate actual direction of edge
             
            /* Convert actual edge direction to approximate value */
            if ( ( (thisAngle < 22.5) && (thisAngle > -22.5) ) || (thisAngle > 157.5) || (thisAngle < -157.5) )
                newAngle = 0;
            if ( ( (thisAngle > 22.5) && (thisAngle < 67.5) ) || ( (thisAngle < -112.5) && (thisAngle > -157.5) ) )
                newAngle = 45;
            if ( ( (thisAngle > 67.5) && (thisAngle < 112.5) ) || ( (thisAngle < -67.5) && (thisAngle > -112.5) ) )
                newAngle = 90;
            if ( ( (thisAngle > 112.5) && (thisAngle < 157.5) ) || ( (thisAngle < -22.5) && (thisAngle > -67.5) ) )
                newAngle = 135;
                 
            edgeDir[row][col] = newAngle;       // Store the approximate edge direction of each pixel in one array
        }
    }
 
    /* Trace along all the edges in the image */
    for (row = 1; row < H - 1; row++) {
        for (col = 1; col < W - 1; col++) {
            edgeEnd = false;
            if (gradient[row][col] > upperThreshold) {       // Check to see if current pixel has a high enough gradient strength to be part of an edge
                /* Switch based on current pixel's edge direction */
                switch (edgeDir[row][col]){    
                    case 0:
                        findEdge(0, 1, row, col, 0, lowerThreshold);
                        break;
                    case 45:
                        findEdge(1, 1, row, col, 45, lowerThreshold);
                        break;
                    case 90:
                        findEdge(1, 0, row, col, 90, lowerThreshold);
                        break;
                    case 135:
                        findEdge(1, -1, row, col, 135, lowerThreshold);
                        break;
                    default :
                        i = (unsigned long)(row*3*W + 3*col);
                        *(m_destinationBmp + i) =
                        *(m_destinationBmp + i + 1) =
                        *(m_destinationBmp + i + 2) = 0;
                        break;
                    }
                }
            else {
                i = (unsigned long)(row*3*W + 3*col);
                    *(m_destinationBmp + i) =
                    *(m_destinationBmp + i + 1) =
                    *(m_destinationBmp + i + 2) = 0;
            }  
        }
    }
     
    /* Suppress any pixels not changed by the edge tracing */
    for (row = 0; row < H; row++) {
        for (col = 0; col < W; col++) { 
            // Recall each pixel is composed of 3 bytes
            i = (unsigned long)(row*3*W + 3*col);
            // If a pixel's grayValue is not black or white make it black
            if( ((*(m_destinationBmp + i) != 255) && (*(m_destinationBmp + i) != 0)) || ((*(m_destinationBmp + i + 1) != 255) && (*(m_destinationBmp + i + 1) != 0)) || ((*(m_destinationBmp + i + 2) != 255) && (*(m_destinationBmp + i + 2) != 0)) )
                *(m_destinationBmp + i) =
                *(m_destinationBmp + i + 1) =
                *(m_destinationBmp + i + 2) = 0; // Make pixel black
        }
    }
 
    /* Non-maximum Suppression */
    for (row = 1; row < H - 1; row++) {
        for (col = 1; col < W - 1; col++) {
            i = (unsigned long)(row*3*W + 3*col);
            if (*(m_destinationBmp + i) == 255) {       // Check to see if current pixel is an edge
                /* Switch based on current pixel's edge direction */
                switch (edgeDir[row][col]) {       
                    case 0:
                        suppressNonMax( 1, 0, row, col, 0, lowerThreshold);
                        break;
                    case 45:
                        suppressNonMax( 1, -1, row, col, 45, lowerThreshold);
                        break;
                    case 90:
                        suppressNonMax( 0, 1, row, col, 90, lowerThreshold);
                        break;
                    case 135:
                        suppressNonMax( 1, 1, row, col, 135, lowerThreshold);
                        break;
                    default :
                        break;
                }
            }  
        }
    }
     
}
 
void CTripodDlg::findEdge(int rowShift, int colShift, int row, int col, int dir, int lowerThreshold)
{
    int W = 320;
    int H = 240;
    int newRow;
    int newCol;
    unsigned long i;
    bool edgeEnd = false;
 
    /* Find the row and column values for the next possible pixel on the edge */
    if (colShift < 0) {
        if (col > 0)
            newCol = col + colShift;
        else
            edgeEnd = true;
    } else if (col < W - 1) {
        newCol = col + colShift;
    } else
        edgeEnd = true;     // If the next pixel would be off image, don't do the while loop
    if (rowShift < 0) {
        if (row > 0)
            newRow = row + rowShift;
        else
            edgeEnd = true;
    } else if (row < H - 1) {
        newRow = row + rowShift;
    } else
        edgeEnd = true;
         
    /* Determine edge directions and gradient strengths */
    while ( (edgeDir[newRow][newCol]==dir) && !edgeEnd && (gradient[newRow][newCol] > lowerThreshold) ) {
        /* Set the new pixel as white to show it is an edge */
        i = (unsigned long)(newRow*3*W + 3*newCol);
        *(m_destinationBmp + i) =
        *(m_destinationBmp + i + 1) =
        *(m_destinationBmp + i + 2) = 255;
        if (colShift < 0) {
            if (newCol > 0)
                newCol = newCol + colShift;
            else
                edgeEnd = true;
        } else if (newCol < W - 1) {
            newCol = newCol + colShift;
        } else
            edgeEnd = true;
        if (rowShift < 0) {
            if (newRow > 0)
                newRow = newRow + rowShift;
            else
                edgeEnd = true;
        } else if (newRow < H - 1) {
            newRow = newRow + rowShift;
        } else
            edgeEnd = true;
    }  
}
 
void CTripodDlg::suppressNonMax(int rowShift, int colShift, int row, int col, int dir, int lowerThreshold)
{
    int W = 320;
    int H = 240;
    int newRow = 0;
    int newCol = 0;
    unsigned long i;
    bool edgeEnd = false;
    float nonMax[320][3];           // Temporarily stores gradients and positions of pixels in parallel edges
    int pixelCount = 0;                 // Stores the number of pixels in parallel edges
    int count;                      // A for loop counter
    int max[3];                     // Maximum point in a wide edge
     
    if (colShift < 0) {
        if (col > 0)
            newCol = col + colShift;
        else
            edgeEnd = true;
    } else if (col < W - 1) {
        newCol = col + colShift;
    } else
        edgeEnd = true;     // If the next pixel would be off image, don't do the while loop
    if (rowShift < 0) {
        if (row > 0)
            newRow = row + rowShift;
        else
            edgeEnd = true;
    } else if (row < H - 1) {
        newRow = row + rowShift;
    } else
        edgeEnd = true;
    i = (unsigned long)(newRow*3*W + 3*newCol);
    /* Find non-maximum parallel edges tracing up */
    while ((edgeDir[newRow][newCol] == dir) && !edgeEnd && (*(m_destinationBmp + i) == 255)) {
        if (colShift < 0) {
            if (newCol > 0)
                newCol = newCol + colShift;
            else
                edgeEnd = true;
        } else if (newCol < W - 1) {
            newCol = newCol + colShift;
        } else
            edgeEnd = true;
        if (rowShift < 0) {
            if (newRow > 0)
                newRow = newRow + rowShift;
            else
                edgeEnd = true;
        } else if (newRow < H - 1) {
            newRow = newRow + rowShift;
        } else
            edgeEnd = true;
        nonMax[pixelCount][0] = newRow;
        nonMax[pixelCount][1] = newCol;
        nonMax[pixelCount][2] = gradient[newRow][newCol];
        pixelCount++;
        i = (unsigned long)(newRow*3*W + 3*newCol);
    }
 
    /* Find non-maximum parallel edges tracing down */
    edgeEnd = false;
    colShift *= -1;
    rowShift *= -1;
    if (colShift < 0) {
        if (col > 0)
            newCol = col + colShift;
        else
            edgeEnd = true;
    } else if (col < W - 1) {
        newCol = col + colShift;
    } else
        edgeEnd = true;
    if (rowShift < 0) {
        if (row > 0)
            newRow = row + rowShift;
        else
            edgeEnd = true;
    } else if (row < H - 1) {
        newRow = row + rowShift;
    } else
        edgeEnd = true;
    i = (unsigned long)(newRow*3*W + 3*newCol);
    while ((edgeDir[newRow][newCol] == dir) && !edgeEnd && (*(m_destinationBmp + i) == 255)) {
        if (colShift < 0) {
            if (newCol > 0)
                newCol = newCol + colShift;
            else
                edgeEnd = true;
        } else if (newCol < W - 1) {
            newCol = newCol + colShift;
        } else
            edgeEnd = true;
        if (rowShift < 0) {
            if (newRow > 0)
                newRow = newRow + rowShift;
            else
                edgeEnd = true;
        } else if (newRow < H - 1) {
            newRow = newRow + rowShift;
        } else
            edgeEnd = true;
        nonMax[pixelCount][0] = newRow;
        nonMax[pixelCount][1] = newCol;
        nonMax[pixelCount][2] = gradient[newRow][newCol];
        pixelCount++;
        i = (unsigned long)(newRow*3*W + 3*newCol);
    }
 
    /* Suppress non-maximum edges */
    max[0] = 0;
    max[1] = 0;
    max[2] = 0;
    for (count = 0; count < pixelCount; count++) {
        if (nonMax[count][2] > max[2]) {
            max[0] = nonMax[count][0];
            max[1] = nonMax[count][1];
            max[2] = nonMax[count][2];
        }
    }
    for (count = 0; count < pixelCount; count++) {
        i = (unsigned long)(nonMax[count][0]*3*W + 3*nonMax[count][1]);
        *(m_destinationBmp + i) =
        *(m_destinationBmp + i + 1) =
        *(m_destinationBmp + i + 2) = 0;
    }
}

 

دانلود کد فوق از طریق لینک زیر:

Canny in C++ -No2

رمز فایل : behsanandish.com

الگوریتم Canny در سی پلاس پلاس قسمت 1
الگوریتم Canny در سی پلاس پلاس قسمت 2
الگوریتم Canny در سی پلاس پلاس قسمت 3
الگوریتم Canny در سی پلاس پلاس قسمت 4

/0 دیدگاه /توسط

عامل های هوشمند قسمت 4

♦ عامل های مبتنی بر هدف (goal-based agents)

داشتن اطلاعات در مورد حالت فعلی محیط، همیشه برای تصمیم گیری در مورد عملی که باید انجام گیرد، کافی نیست. به عنوان مثال، در جاده، تاکسی می تواند به چپ، راست یا مستقیم برود. تصمیم گیری درست، به مقصد تاکسی بستگی دارد. به عبارت دیگر، علاوه بر توصیف حالت فعلی، عامل به اطلاعات هدف نیاز دارد که موقعیت مطلوب را توصیف می کند. بعنوان مثال، می توان به مقصد مسافر اشاره کرد. “برنامه عامل” می تواند این اطلاعات را با اطلاعاتی دزبازه نتایج فعالیتهای ممکن ترکیب کندتا فعالیتی را برای رسیدن به هدف انتخاب نماید.

گاهی انتخاب فعالیت در عامل مبتنی بر هدف آسان است (وقتی که رضایت از هدف، بلافاصله از یک فعالیت به دست می آید). گاهی این انتخاب پیچیده خواهد بود (وقتی که عامل باید دنباله های طولانی را در نظر بگیرد تا راهی برای دستیابی به هدف پیدا کند). جست وجو و برنامه ریزی ، حوزه های فرعی AI هستند که دنباله ای از فعالیت ها را برای دستیابی عامل به هدف، پیدا می کنند.

توجه کنید که این نوع تصمیم گیری با “قوانین شرط فعالیت” که شرح آنها گذشت متفاوت است، به طوری که باید آینده را در نظر گرفت: “اگر چنین و چنان کنم، چه اتفاقی می افتد؟” ، “این مراحل مرا خوشحال می کند”. در طراحی های عامل واکنشی، این اطلاعات صریحا نمایش داده نمی شوند، زیرا قوانین داخلی، مستقیما از ادراکات به فعالیت ها نگاشت می شوند. عامل واکنشی، وقتی ترمز می کند که لامپ های ترمز را ببیند. در اصل عامل مبتنی بر هدف نتیجه می گیرد که اگر چراغ ترمز اتومبیل جلویی روشن شود، سرعت آن کاهش می یابد. با توجه به چگونگی تکامل جهان، تنها عملی که منجر به برخورد با اتومبیل دیگر نمیشود، ترمز کردن است.

گرچه عامل مبتنی ببر هدف کارایی چندانی ندارد، قابلیت انعطاف آن بیشتر است. زیرا دانشی که از تصمیمات آن پشتیبانی می کند، صریحا نمایش داده می شود و قابل اصلاح است. برای عامل واکنشی، باید بسیاری از “قوانین شرط فعالیت” را بازنویسی کنیم. رفتار عامل مبتنی بر هدف می تواند تغییر کند تا به هدف مورد نظر برسد.

♦ عامل های مبتنی بر سودمندی (utility-based agents)

در بسیاری از محیط ها، اهداف، برای تولید رفتاری با کیفیت بالا کافی نیستند. بعنوان مثال، چندین دنباله از فعالیت ها وجود دارند که تاکسی را به مقصد می رسانند، اما بعضی از آنها سریع تر، امن تر، مطمئن تر یا ارزانتر از دنباله های دیگر است. اهداف آنها، فقط ملاک ناپخته ای را بین وضعیت “رضایت” و “نارضایتی” ارائه میکنند، در حالیکه معیار کارایی عمومی باید مقایسه ای بین وضعیت های دنیای متفاوت (با دنباله حالات) را براساس چگونگی رضایت عامل، در صورت نائل شدن به هدف ارائه کند.

چون “رضایت” اساس علمی ندارد، دانشمندان کامپیوتر و اقتصاد از واژه ی “سود” یا “سودمندی” استفاده می کنند. “معیار کارایی” به هر دنباله از حالتهای محیط، امتیازی را نسبت می دهد، و به این ترتیب می تواند بین مسیرهای مطلوب تر و نامطلوب برای رسیدن به مقصد تاکسی، تمایز قائل شود. تابع سودمندی عامل، معیار کارایی را در داخل عامل تعیین می کند. اگر “تابع سودمندی داخلی” و “معیار کارایی خارجی” سازگار باشند، آنگاه عاملی که فعالیت هایی را برای ماکزیمم کردن سودمندی خود انتخاب می کند، خردمندانه عمل می کند.

این روش، تنها روش خردمند بودن نیست، اما همانند عامل های مبتنی بر هدف، عامل های مبتنی بر سودمندی از نظر قابلیت انعطاف و یادگیری، امتیازات زیادی دارند. علاوه بر این، در دو مورد اهداف چندان روشن نیستند، ولی عامل مبتنی بر سودمندی هنوز میتواند تصمیمات خردمندانه بگیرد.

اولا، وقتی اهداف با هم متضاد باشند فقط بعضی از آنها قابل دستیابی هستند، که در این مورد تابع سودمندی، توازن مناسبی را بین اهداف متضاد برقرار میکند. ثانیا، وقتی چندین هدف وجود دارند که عامل میتواندبرای دستیابی به آنها کمک کند،ولی هیچ کدام از آنها با اطمینان قابل دستیابی نباشند، تابع سودمندی میتواند احتمال موفقیت اهداف را بر حسب اهمیت آنها ، افزایش دهد.

خاصیت “پاره ای قابل مشاهده” و خاصیت اتفاقی، در سراسر دنیای واقعی وجود دارد. و در نتیجه، تصمیم گیری تحت شرایط عدم اطمینان انجام می شود. از نظر تکنیکی، عامل خردمند مبتنی بر سودمندی، فعالیتی را انتخاب میکند که سود مورد انتظار مربوط به نتایج آن فعالیت، ماکزیمم باشد. منظور از سود مورد انتظارف سودی است که عامل انتظار دارد بطور میانگین، با توجه به احتمالات و سود هر یک از نتایج، به دست آورد. عاملی که دارای یک “تابع سودمندی” صریح است، می تواند تصمیم خردمندانه اتخاذ کند. برای این تصمیم گیری ،از یک الگوریتم همه منظوره استفاده میکند که به تابع سودمندی خاصی بستگی ندارد.

ماهیت محیط های عامل های هوشمند

برای ساخت عاملهای خردمند، ابتدا باید راجع به محیط های کار فکر کنیم که “مسئله هایی” هستند که عاملهای هوشمند باید آنها را حل کنند. ابتدا چگونگی مشخص کردن محیط کار را بررسی میکنیم، سپس نشان خواهیم داد که محیط های کار، تنوع زیادی دارند. هر نوع محیط وظیفه، مستقیما، طراحی مناسب “برنامه ی عامل” را تحت تاثیر قرار میدهد.

تعیین کردن محیط کار

تعیین نوع عامل، معیار کارایی، محیط، حسگرها (سنسورها) و محرک ها را تحت عنوان محیط کار دسته بندی می کنیم. برای خلاصه ، این ها را به نام PEAS می خوانیم. اولین قدم در طراحی عامل، مشخص کردن محیط کار آن است. برای مثال، از مسئله ی “راننده تاکسی خودکار” (اتوماتیک) استفاده میکنیم. توجه کنید که تاکسی خودکار مورد بحث ما، خارج از قابلیت های فناوری فعلی است. وظیفه رانندگی، محدودیتی در ترکیب شرایط ندارد. هر یک از عناصر محیط کار را بیشتر مورد بحث قرار میدهیم.

معیار کارایی مربوط به راننده خودکار چییست؟ کیفیت های مطلوب عبارتنداز: رسیدن به مقصد درست، کم بودن مصرف سوخت و استهلاک، کم کردن زمان مسافرت و هزینه، کم کردن نقض قوانین ترافیک و اذیت کردن سایر رانندگان، حداکثر امنیت و راحتی مسافر، حداکثر سود. بدیهی است که بعضی از این اهداف متضاد هستند و باید متوازن شوند.

محیط تاکسی کجاست؟ هر راننده تاکسی باید با جاده ها سروکار داشته باشد، از جاده های یک طرفه تا بزرگ راه ها. جاده ها شامل ترافیک دیگری است، مثل عابرین پیاده، حیوانات، کارهای جاده ای، اتومبیل پلیس، چاله ها و دست اندازها. تاکسی باید با مسافران واقعی و بالقوه نیز سروکار داشته باشد. انتخاب های اختیاری نیز سر راه تاکسی وجود دارند. تاکسی ممکن است در سمت راست یا چپ حرکت کند، یا در جایی حرکت کند که برف عامل مهمی است. بدیهی است که هر چه محیط محدودتر باشد، مسئله طراحی آسانتر خواهد بود.

محرک هایی که برای راننده خودکار مهیا هستند، شامل آنهایی است که برای راننده انسانی فراهم است: کنترل موتور از طریق گاز، و کنترل مسیر و ترمز. علاوه براین باید با نمایش خروجی در نمایشگر یا دستگاه صوتی، با مسافران صحبت کند، با وسایل نقلیه دیگر ارتباط برقرار کند و غیره.

تاکسی برای رسیدن به هدف خود در محیط رانندگی، باید موقعیت و سرعت فعلی خود را بداند. لذا حسگرهای اصلی آن شامل یک یا چند دوربین تصویربرداری قابل کنترل، سرعت سنج و کیلومتر شمار است. برای کنترل مناسب تاکسی، به خصوص در سر پیچ ها، باید شتاب سنج داشته باشد. باید از وضعیت مکانیکی تاکسی خبر داشته باشد، لذا نیاز به حسگر های موتور، سوخت و سیستم الکتریکی است. باید ابزارهایی داشته باشد که در تاکسی معمولی وجود ندارد: سسیستم ماهواره تعیین موقعیت جهانی (GPS) که اطلاعات مربوط به موقعیت را به همراه یک نقشه در اختیار آن قرار می دهد، حسگرهای مادون قرمز یا سونار، تا فاصله آن را از سایر وسایل نقلیه مشخص کند. نیاز به صفحه کلید یا میکروفون دارد تا با مسافران ارتباط برقرار کند و مسافران مقصد خود را اعلان کنند.

عامل های نرم افزاری (یا روبات های نرم افزاری یا softbots ) در حوزه های وسیع و متعددی وجود دارند. یک روبات نرم افزاری را در نظر بگیرید که برای شبیه سازی پرواز هواپیمای بزرگ طراحی شده است. شبیه ساز شامل محیط پیچیده و با جزئیات زیاد است که حاوی هواپیما ها و عملیات زمینی است و عامل نرم افزاری باید فعالیت های متنوعی را در زمان بی درنگ انتخاب کند. برای این کار باید توانایی پردازش زبان طبیعی را داشته باشد، باید بیاموزد که هر مشتری به چه چیزی علاقمند است، و نقشه اش را بطور پویا (دینامیک) تغییر دهد. اینترنت محیطی است که پیچیدگی آن با دنیای فیزیکی برابری می کند و سکنه ی آن شامل عامل های مصنوعی متعددی هستند.

خواص محیط های کار (task environment)

بدیهی است که حدود محیط های کار AI بسیار گسترده است. می توانیم محیط های کار را به چند بعد تقسیم کنیم. این ابعاد، طراحی مناسب عامل و قابلیت اجرای هر خانواده از تکنیک ها را برای محیط عامل تعیین میکنند. این ابعاد عبارتنداز:

• “کاملا قابل مشاهده” در مقابل “پاره ای قابل مشاهده” (Fully observable vs. partially observable) :

اگر سنسور ها یا حسگرهای عامل، در هر زمان امکان دستیابی کامل به حالت محیط را فراهم کنند، می گوییم آن محیط کاملا قابل مشاهده است. محیط وظیفه، وقتی کاملا قابل مشاهده است که حسگرها تمام جنبه های مرتبط با فعالیت را تشخیص دهند. مرتبط بودن، به معیار کارایی بستگی دارد، محیط های کاملا قابل مشاهده، راحت هستند، زیرا لازم نیست عامل هیچ “حالت داخلی” را برای ردیابی دنیای خارج نگهداری کند. محیط ممکن است به دلیل وجود حسگرهای شلوغ و غیر دقیق ، از دست دادن بخشی از حالت توسط حسگر، کاملا قابل مشاهده نباشد.به عنوان مثال، تاکسی خودکار نمیتواند ببیند که رانندگان دیگر در حال فکر کردن هستند. اگر عامل فاقد سنسور باشد، آنگاه محیط آن غیر قابل مشاهده است. ممکن است تصور کنید که در اینگونه موارد، عامل نتواند به هدف خود برسد، اما اینطور نیست.

• تک عاملی در برابر چند عاملی (Single agent vs. multiagent) :

تمایز بین محیط های تک عاملی و چند عاملی، ساده به نظر می رسد. به عنوان مثال، عاملی که جدول کلمات متقاطع را به تنهایی حل می کند، بدیهی است که در محیط تک عاملی قرار دارد. در حالیکه عاملی که شطرنج بازی میکند در محیط دو عاملی قرار دارد. نکات ظریفی وجود دارد، که باید بررسی شود. اولا توضیح دادیم که چگونه یک موجودیت، به عنوان یک عامل در نظر گرفته می شود، ولی توضیح ندادیم که کدام موجودیت ها باید به عنوان عامل دیده شوند. آیا عامل A (مثل راننده تاکسی) باید با شی ء B (وسیله نقلیه دیگر) به عنوان یک عامل رفتار کند، یا میتواند با آن به عنوان شی ئی برخورد کند که براساس قوانین فیزیکی رفتار می کند، مثل موج ساحل یا حرکت برگها در اثر باد؟ نکته مهم این است که آیا بهتر است رفتار B به عنوان ماکزیمم کننده ی معیار کارایی توصیف شود که مقدار آن به رفتار عامل A بستگی دارد یا خیر. بعنوان مثال، در شطرنج، رقیب موجودیت B سعی میکندمعیار کارایی را به حداکثر برساند، و براساس قاعده شطرنج، معیار کارایی عامل A به حداقل برسد. لذا، شطرنج، یک محیط چند عاملی رقابتی است. از طرف دیگر، در محیط رانندگی تاکسی، اجتناب از تصادف ها، میزان کارایی تمام عامل ها را افزایش می دهد و در نتیجه ، این محیط یک محیط چندعاملی همیاری جزئی است. به این دلیل که، مثلا فقط یک اتومبیل می تواند فضای پارک را به خود اختصاص دهد. مشکلاتی که در طراحی عامل در محیط چند عاملی رخ میدهد، متفاوت از محیط تک عاملی است. به عنوان مثال، در محیط های چند عاملی، ارتباطات غالبا به عنوان رفتار عقلایی عامل ها ظاهر می شود. در بعضی از محیط های رقابتی، رفتار تصادفی، عقلایی است، زیرا مشکلات قابلیت پیش بینی را ندارند. 

• قطعی در مقابل اتفاقی (Deterministic vs. stochastic) :

اگر حالت بعدی محیط کاملا توسط حالت فعلی و عملی که عامل در حال انجام آن است، کاملا قابل تعیین باشد، می گوییم این محیط، قطعی است، وگرنه این محیط اتفاقی است. در اصل، عامل نباید در یک محیط قطعی و کاملا قابل مشاهده، نگران عدم اطمینان باشد. (در تعریف ما، عدم اطمینان ناشی از سایر عامل ها را در محیط چند عامل، نادیده می گیریم؛ بنابراین، در یک بازی حتی اگر هیچ عاملی نتواند فعالیت های عامل های دیگر را پیش بینی کند، این بازی میتواند قطعی باشد). اگر محیط پاره ای قابل مشاهده باشد، ممکن است اتفاقی به نظر برسد. بعضی از وضعیت های واقعی، آنقدر پیچیده هستند که نگهداری تمام جنبه های مشاهده نشده ی آن، غیر ممکن است؛ برای اهداف عملی، باید با آنها بصورت غیر قطعی یا اتفاقی رفتار کرد. اگر محیطی کاملا قابل مشاهده نباشد یا غیر قطعی باشد، می گوییم این محیط غیر قابل اعتماد یا نامطمئن است. منظور از واژه ی “غیر قطعی” این است که عدم اعتماد نسبت به نتایج، بر حسب احتمالات تعیین میشود؛ محیط غیر قطعی، محیطی است که در آن، فعالیت ها بر اساس نتایج ممکن مشخص می گردد، ولی هیچ احتمالی به آنها نسبت داده نمیشود. توصیف های محیط غیر قطعی، معمولا همراه با معیارهای کارایی است که برای موفقیت عامل در تمام نتایج ممکن از فعالیت های خود، ضروری است.

• مرحله ای در مقابل ترتیبی (Episodic vs. sequential) :

در یک محیط کار مرحله ای (تقسیم پذیر) ، تجربه ی عامل به چند بخش اتمیک و یکپارچه تقسیم می شود. در هر مرحله، عامل چیزی را درک میکند و یک عمل را بر اساس آن انجام می دهد. مرحله ی بعدی، به فعالیتهای انجام شده در مراحل قبل بستگی ندارد. بسیاری از وظایف طبقه بندی، مرحله ای هستند. برای مثال، عاملی که باید قطعات معیوب را در خط مونتاژ علامت گذاری کند، براساس قطعه ی فعلی تصمیم میگیرد، و این تصمیم گیری ربطی به تصمیم گیری های قبلی ندارد. علاوه براین،تصمیمی که بر روی قطعه یفعلی گرفته میشود، تاثیری در معیوب بودن قطعه ی بعدی ندارد. از طرف دیگر در محیط های ترتیبی یا پی در پی، تصمیم فعلی میتواند برر تمام تصمیمیات بعدی موثر باشد. شطرنج و رانندگی تاکسی، محیط های ترتیبی دارند: در هر دو مورد فعالیت های کوتاه مدت میتواند نتایج دراز مدتی داشته باشد. محیط های مرحله ای خیلی ساده تر از محیط های ترتیبی هستند، زیرا لازم نیست عامل درباره آینده فکرکند.

• ایستا در مقابل پویا (Static vs. dynamic) :

اگر محیط در طول عمر عامل تغییر کند، می گوییم آن محیط برای آن عامل پویا ، وگرنه ایستا است. کار کردن در محیط های ایستا ساده است، زیرا لازم نیست عامل در هنگام تصمیم گیری، دنیا را ببیند و لازم نیست نسبت به زمان گذشته نگران باشد. محیط های پویا بطور پیوسته از عامل سوال میکنند که چه کاری می خواهد انجام دهد. اگر هنوز تصمیم نگرفته باشد، معنایش این است که تصمیم گرفته است کاری انجام ندهد. اگر محیط با گذر زمان تغییر نکند، ولی امتیازات کارایی عامل تغییر کند، می گوییم محیط نیمه پویا است. رانندگی تاکسی پویا است. اتومبیل های دیگر و خود تاکسی در حال حرکت هستند، در حالیکه الگوریتم رانندگی باید برای مرحله بعدی تصمیم بگیرد. اگر در بازی شطرنج فقط زمان مطرح باشد، نیمه پویا است.

• گسسته در مقابل پیوسته (Discrete vs. continuous) :

تمایز بین وضعیت گسسته و پیوسته می تواند به حالت محیط، اداره کردن زمان، و به ادراکات و فعالیت های عامل اعمال شود. به عنوان مثال، محیط گسسته مثل بازی شطرنج دارای چند حالت مجزای متناهی است. شطرنج دارای مجموعه گسسته ای از ادراکات و فعالیت هاست. رانندگی تاکسی یک مسئله حالت پیوسته و زمان پیوسته است: سرعت و مکان تاکسی و سایر وسایل نقلیه. از طریق بازه ای از مقادیر پیوسته عبور می کند و این کار را بطور یکنواخت در طول زمان انجام می دهد.

• شناخته شده در مقابل ناشناخته (Known vs. unknown) :

به عبارت دقیق تر، این تمایز به خود محیط مربوط نمیشود، بلکه به حالت دانش عامل در مورد “قوانین فیزیکی” محیط مربوط می شود. در محیط شناخته شده، نتایج مربوط به تمام فعالیت ها داده می شود. روشن است اگر محیط ناشناخته باشد عامل باید یاد بگیرد که این محیط چگونه کار می کند، تا بتواند تصمیمات درستی اتخاذ کند. توجه کنید که تمایز بین محیط های شناخته شده و ناشناخته، مثل تمایز بین محیط های کاملا “قابل مشاهده” و “پاره ای قابل مشاهده” نیست. ممکن است یک محیط شناخته شده ، بطور پاره ای قابل مشاهده باشد. برعکس، محیط ناشناخته میتواند کاملا قابل مشاهده باشد.

 

/0 دیدگاه /توسط

استفاده از WhenAll برای اجرای چندین Task

استفاده از متد WhenAll برای اجرای چندین Task به صورت همزمان در سی شارپ

فرض کنید که داخل یک متد باید چندین متد را به صورت await فراخوانی کنید. به صورت عادی زمانی که متدها فراخوانی می شوند هر بخش await بعد از تکمیل await قبلی اجرا خواهد شد و مقادیر بازگشتی به صورت یکجا در اختیار شما قرار نمیگیرند. برای مثال، کد زیر را در نظر بگیرید:

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
private async void AsyncBtn_Click(object sender, EventArgs e)
{
    Result1TextBox.Text = (await Task1()).ToString();
    Result12extBox.Text = (await Task2()).ToString();
}
  
private Task < long > Task1()
{
    return Task.Run<long>(() = >
    {
        var num = Enumerable.Repeat(10, 1000);
        long sum = 0;
        foreach (var item in num)
        {
            System.Threading.Thread.Sleep(2);
            sum += item;
        }
        return sum;
    });
}
private Task < long > Task2()
{
    return Task.Run<long>(() = >
    {
        var num = Enumerable.Repeat(10, 1000);
        long sum = 0;
        foreach (var item in num)
        {
            System.Threading.Thread.Sleep(2);
            sum += item;
        }
        return sum;
    });
}

 

در کد بالا، ابتدا عملیات Task1 انجام شده و نتیجه نمایش داده می شود و پس از آن Task2 اجرا شده و نتیجه نمایش داده می شود. برای رفع وقفه بین اجرای دو Task از متد WhenAll استفاده می کنیم. برای استفاده از متد WhenAll کد BtnAsync_Click را به صورت زیر تغییر می دهیم:

 

1
2
3
4
5
6
private async void AsyncBtn_Click(object sender, EventArgs e)
{
    var results = await Task.WhenAll(Task1(), Task2());
    txtBox.Text = results[0].ToString();
    txtSecond.Text = results[1].ToString();
}

 

با ایجاد تغییر کد بالا، خروجی متد WhenAll یک آرایه از نوع long خواهد بود که هر یک از اندیس های آرایه به ترتیب خروجی متدهای اول و دوم می باشد و به صورت بالا می توان خروجی ها را در TextBox ها نمایش داد.

منبع

قسمت اول آموزش-برنامه نویسی Asynchronous – آشنایی با Process ها، Thread ها و AppDomain ها

قسمت دوم آموزش- آشنایی با ماهیت Asynchronous در Delegate ها

قسمت سوم آموزش-آشنایی با فضای نام System.Threading و کلاس Thread

قسمت چهارم آموزش- آشنایی با Thread های Foreground و Background در دات نت

قسمت پنجم آموزش- آشنایی با مشکل Concurrency در برنامه های Multi-Threaded و راهکار های رفع این مشکل

قسمت ششم آموزش- آشنایی با کلاس Timer در زبان سی شارپ

قسمت هفتم آموزش-آشنایی با CLR ThreadPool در دات نت

قسمت هشتم آموزش- مقدمه ای بر Task Parallel Library و کلاس Parallel در دات نت

قسمت نهم آموزش- برنامه نویسی Parallel:آشنایی با کلاس Task در سی شارپ

قسمت دهم آموزش-برنامه نویسی Parallel در سی شارپ :: متوقف کردن Task ها در سی شارپ – کلاس CancellationToken

قسمت یازدهم آموزش- برنامه نویسی Parallel در سی شارپ :: کوئری های Parallel در LINQ

قسمت دوازدهم آموزش- آشنایی با کلمات کلیدی async و await در زبان سی شارپ

قسمت سیزدهم آموزش- استفاده از متد WhenAll برای اجرای چندین Task به صورت همزمان در سی شارپ

 

 

 

/0 دیدگاه /توسط

مشکل Concurrency در برنامه های Multi-Threaded

کار با Thread ها در زبان سی شارپ :: آشنایی با مشکل Concurrency در برنامه های Multi-Threaded و راهکار های رفع این مشکل

زمانی که ما برنامه های Multi-Threaded می نویسیم، برخی اوقات Thread های ایجاد شده به داده های مشترک در سطح برنامه دسترسی دارند و وظیفه ما به عنوان برنامه نویس این است که مطمئن باشیم دسترسی چند Thread به داده های مشترک باعث بروز مشکل نمی شود. برای آشنایی بیشتر با این موضوع شرایطی را در نظر بگیرید که یک متد قرار است در چندین thread مختلف به صورت جداگانه اجرا شود، بعد از شروع کار هر thread زمانبندی اجرا توسط CLR به هر thread به صورت خودکار انجام شده و ما نمی توانیم دخالتی در این موضوع داشته باشیم، ممکن است در این بین اختصاص زمان به یک thread بیش از thread دیگر انجام شود و در این بین خروجی مناسب مد نظر ما ایجاد نمی شود. برای آشنایی با این موضوع متد PrintNumbers که در زیر تعریف کردیم را در نظر بگیرید:

1
2
3
4
5
6
7
8
9
10
public static void PrintNumbers()
{
    Console.Write("{0} is printing numbers  >  " , Thread.CurrentThread.Name);
    for (int counter = 0; counter  <  10 ;  counter++)
    {
        Thread.Sleep(200*new Random().Next(5));
        Console.Write("{0},", counter);
    }
    Console.WriteLine();
}

در مرحله بعد متد Main را به صورت زیر تغییر می دهیم تا 10 thread ایجاد شده و سپس کلیه thread ها اجرا شوند:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Thread[] threads = new Thread[10];
 
for (int index = 0; index  <  10 ;  index++)
{
    threads[index] = new Thread(PrintNumbers);
    threads[index].Name = string.Format("Worker thread #{0}.", index);
}
 
foreach (var thread in threads)
{
    thread.Start();
}
 
Console.ReadLine();

همانطور که مشاهده می کنید کلیه thread ها به صورت همزمان اجرا می شوند، اما پس از اجرا کد بالا، خروجی برای بار اول به صورت خواهد بود، البته دقت کنید که با هر بار اجرا خروجی تغییر می کند و ممکن است برای بار اول خروجی زیر برای شما تولید نشود:

1
2
3
4
5
6
7
8
9
10
Worker thread #0. is printing numbers  >  Worker thread #1. is printing numbers  >  Worker thread #2. is printing numbers  >  Worker thread #3. is printing numbers  >  0,Worker thread #4. is printing numbers  >  0,1,1,2,3,2,Worker thread #5. is printing numbers  >  0,4,3,1,4,2,5,Worker thread #6. is printing numbers  >  5,3,Worker thread #7. is printing numbers  >  4,6,6,0,Worker thread #8. is printing numbers  >  Worker thread #9. is printing numbers  >  0,0,7,5,7,0,1,0,1,0,6,8,8,1,2,1,1,0,2,9,
7,3,2,2,9,
2,1,8,3,3,3,4,2,1,9,
4,4,4,5,3,3,5,5,5,6,2,6,6,7,6,4,4,7,7,8,9,
8,9,
7,8,9,
5,5,3,8,6,7,8,9,
6,7,8,9,
4,5,9,
6,7,8,9,

اگر برنامه را مجدد اجرا کنید خروجی متفاوتی از خروجی قبلی دریافت خواهیم کرد:

1
2
3
4
5
6
7
8
9
10
Worker thread #0. is printing numbers  >  Worker thread #1. is printing numbers  >  Worker thread #2. is printing numbers  >  Worker thread #3. is printing numbers  >  Worker thread #4. is printing numbers  >  Worker thread #5. is printing numbers  >  Worker thread #6. is printing numbers  >  0,Worker thread #7. is printing numbers  >  1,2,0,1,3,2,4,3,Worker thread #8. is printing numbers  >  Worker thread #9. is printing numbers  >  0,0,0,0,0,0,5,4,5,6,7,8,9,
6,7,8,9,
1,1,0,0,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,4,5,6,7,8,9,
3,3,3,3,3,4,4,4,4,5,6,7,8,9,
5,6,7,8,9,
5,6,7,5,6,7,8,9,
8,4,4,4,5,5,6,6,7,7,9,
5,8,8,6,9,
9,
7,8,9,

همانطور که مشاهده می کنید خروجی های ایجاد کاملاً با یکدیگر متفاوت هستند. مشخص است که در اینجا مشکلی وجود دارد و همانطور که در ابتدا گفتیم این مشکل وجود همزمانی یا Concurrency در زمان اجرای thread هاست. زمابندی CPU برای اجرای thread ها متفاوت است و با هر بار اجرا زمان های متفاوتی به thread ها برای اجرا تخصیص داده می شود. اما خوشبختانه مکانیزم های مختلفی برای رفع این مشکل و پیاده سازی Synchronizqation وجوددارد که در ادامه به بررسی راهکاری های مختلف برای حل مشکل همزمانی می پردازیم.

پیاده سازی Synchronization با کلمه کلیدی lock

اولین مکانیزم مدیریت همزمانی در زمان اجرای Thread ها استفاده از کلمه کلیدی lock است. این کلمه کلیدی به شما این اجازه را می دهد تا یک scope مشخص کنید که این scope باید به صورت synchronized بین thread ها به اشتراک گذاشته شود، یعنی زمانی که یک thread وارد scope ای شد که با کلمه کلیدی lock مشخص شده، thread های دیگر باید منتظر شوند تا thread جاری که در scope قرار دارد از آن خارج شود. برای استفاده از lock شما اصطلاحاً می بایست یک token را برای scope مشخص کنید که معمولاً این کار با ایجاد یک شئ از نوع object و مشخص کردن آن به عنوان token برای synchronization استفاده می شود. شیوه کلی استفاده از lock به صورت زیر است:

1
2
3
4
lock(token)
{
    // all code in this scope are thread-safe
}

اصطلاحاً می گویند کلیه کدهایی که در بدنه lock قرار دارند thread-safe هستند. برای اینکه کد داخل متد PrintNumbers به صورت thread-safe اجرا شود، ابتدا باید یک شئ برای استفاده به عنوان token در کلاس Program تعریف کنیم:

1
2
3
4
5
class Program
{
    public static object threadLock = new object();
 
    ....

در قدم بعدی کد داخل متد PrintNumbers را به صورت زیر تغییر می دهیم:

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void PrintNumbers()
{
    lock (threadLock)
    {
        Console.Write("{0} is printing numbers  >  " , Thread.CurrentThread.Name);
        for (int counter = 0; counter  <  10 ; counter++)
        {
            Thread.Sleep(200 * new Random().Next(5));
            Console.Write("{0},", counter);
        }
        Console.WriteLine();
    }
}

با اعمال تغییر بالا، زمانی که thread جدیدی قصد وارد شدن به scope مشخص شده را داشته باشد، باید منتظر بماند تا کار thread جاری به اتمام برسد تا اجرای thread جدید شروع شود. با اعمال تغییر بالا، هر چند بار که کد نوشته شده را اجرا کنید خروجی زیر را دریافت خواهید کرد:

1
2
3
4
5
6
7
8
9
10
Worker thread #0. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #1. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #2. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #3. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #4. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #5. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #6. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #7. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #8. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #9. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,

پیاده سازی Synchronization بوسیله کلاس Monitor

در قسمت قبل که از کلمه کلیدی lock استفاده کردیم، در حقیقت به در پشت زمینه از کلاس Monitor که در فضای نام System.Threading قرار دارد استفاده شده است. زمانی که از کلمه کلیدی lock استفاده می کنیم این کد تبدیل به کدی می شود که از Monitor برای پیاده سازی Synchronization استفاده می کند (می توان این موضوع را با ابزار ildasm.exe و مشاهده کد IL متوجه شد). نحوه استفاده از کلاس Mutex را در کد زیر که تغییر داده شده متد PrintNumbers است مشاهده می کنید:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void PrintNumbers()
{
    Monitor.Enter(threadLock);           
    try
    {
        Console.Write("{0} is printing numbers  >  " , Thread.CurrentThread.Name);
        for (int counter = 0; counter  <  10 ; counter++)
        {
            Thread.Sleep(200*new Random().Next(5));
            Console.Write("{0},", counter);
        }
        Console.WriteLine();
    }
    finally
    {
        Monitor.Exit(threadLock);
    }
}

متد Enter در کلاس Monitor اعلام می کند که thread ای وارد محدوده ای شده است که باید thread-safe باشد. به عنوان پارامتر ورودی برای این متد token ایجاد شده یعنی obj را ارسال می کنیم. در قدم بعدی کل کدی که مربوط به ناحیه thread-safe است باید داخل بدنه try-catch نوشته شود و البته بخش finaly نیز برای آن نوشته شده باشد، همانطور که می دانید بخش finally قسمتی از بدنه try است که در هر صورت اجرا می شود. در قسمت finally متد Exit را با پارامتر threadLock که همان token مربوطه است فراخوانی می کنیم، یعنی thread در حال اجرا از محدوده thread-safe خارج شده است. دلیل نوشتن try-catch در کد بالا این است که در صورت وقوع خطا عملیات خروج از محدوده thread-safe در هر صورت انجام شود و thread های دیگر منتظر ورود به این محدوده نمانند. شاید این سوال برای شما بوجود بیاید که با وجود کلمه کلیدی lock چه دلیلی برای استفاده از کلاس Monitor وجود دارد؟ دلیل این موضوع کنترل بیشتر بر روی ورود thread ها و اجرای کدهای thread-safe است. برای مثال، بوسیله متد Wait در کلاس Monitor می توان مشخص کرد که یک thread چه مدت زمانی را برای ورود به ناحیه thread-safe باید منتظر بماند و همچنین متدهای Pulse و PulseAll را می توان برای اطلاع رسانی به سایر thread ها در مورد اینکه کار thread جاری به اتمام رسیده استفاده کرد. البته در اکثر موقعیت ها استفاده از کلمه کلیدی lock کافی است و نیازی به استفاده از کلاس Monitor نمی باشد.

پیاده سازی Synchronization با استفاده از کلاس Interlocked

زمانی که قصد داریم مقدار یک متغیر را تغییر دهیم یا عملگرهای ریاضی را بر روی دو متغیر اعمال کنیم، عملیات های انجام شده به دو صورت Atomic و Non-Atomic انجام می شوند. مبحث عملیات عملیات های Atomic چیزی بیش از چند خط نیاز دارد تا توضیح داده شود، اما به طور خلاصه می توان گفت که عملیات های Atomic عملیات هایی هستند که تنها در یک مرحله یا step انجام می شوند. اگر کدهای IL مرتبط به مقدار دهی متغیرها و البته عملگرهای ریاضی را بر روی بیشتر نوع های داده در دات نت مشاهده کنیم میبینیم که این عملیات ها بیشتر به صورت non-atomic هستند، یعنی بیش از یک مرحله برای انجام عملیات مربوط نیاز است که این موضوع می تواند در برنامه های Multi-threaded مشکل ساز شود. در حالت ساده می توان بوسیله مکانیزم lock عملیات synchronization را برای این عملیات ها پیاده سازی کرد:

1
2
3
4
5
int value = 1;
lock(token)
{
    value++;
}

اما برای شرایطی مانند مثال بالا استفاده از lock یا کلاس monitor باعث ایجاد overhead اضافی می شود که برای حل این مشکل می توان از کلاس Interlocked برای اعمال synchronization در اعمال انتساب مقدار یا مقایسه مقادیر استفاده کرد. برای مثال، زمانی که می خواهیم مقدار یک متغیر را با استفاده از کلاس Interlocked اضافه کنیم به صورت می توانیم این کار را پیاده سازی کنیم:

1
2
int myNumber = 10;
Interlocked.Increment(ref myNumber);

متد Increment در کلاس Interlocked یک مقدار به متغیر مشخص شده اضافه می کند و البته این کار در محیط Thread-Safe انجام می شود. برای کاهش مقدار می توان از متد Decrement به صورت مشابه استفاده کرد:

1
2
int myNumber = 10;
Interlocked.Decrement(ref myNumber);

همچنین برای مقایسه و مقدار دهی مقدار یک متغیر می توان از متد CompareExchange استفاده به صورت زیر استفاده کرد:

1
2
int myNumber = 10;
Interlocked.CompareExchange(ref myNumber, 15, 10);

در کد بالا در صورتی که مقدار متغیر myNumber برابر 10 باشد، مقدار آن با 15 عوض خواهد شد.

پیاده سازی Synchronization بوسیله خاصیت [Synchronization]

می دانیم که خاصیت [Synchronization] زمانی که بر روی یک کلاس قرار میگیرد، باعث می شود که کد داخل آن کلاس به صورت Thread-Safe اجرا شود. در این قسمت می خواهیم کد مربوط به متد PrintNumbers را به صورت Thread-Safe و با کمک Object Context Boundry و همچنین خاصیت [Synchronization] پیاده سازی کنیم. برای این کار ابتدا یک کلاس با نام Printer پیاده سازی کرده و متد PrintNumbers را داخل آن قرار می دهیم. دقت کنید که کلاس Printer می بایست از کلاس ContextBoundObject مشتق شده باشد و خاصیت [Synchronization] بر روی آن قرار گرفته باشد:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[Synchronization]
public class Printer : ContextBoundObject
{
    public void PrintNumbers()
    {
        Console.Write("{0} is printing numbers  >  " , Thread.CurrentThread.Name);
        for (int counter = 0; counter  <  10 ; counter++)
        {
            Thread.Sleep(200*new Random().Next(5));
            Console.Write("{0},", counter);
        }
        Console.WriteLine();
    }
}

پس از انجام تغییرات بالا متد Main را به صورتی تغییر می دهیم که از متد Print در کلاس Printer استفاده کند:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Printer printer = new Printer();
 
Thread[] threads = new Thread[10];
 
for (int index = 0; index  <  10 ; index++)
{
    threads[index] = new Thread(printer.PrintNumbers);
    threads[index].Name = string.Format("Worker thread #{0}.", index);
}
 
foreach (var thread in threads)
{
    thread.Start();
}
 
Console.ReadLine();

با انجام کارهای بالا و اجرای برنامه مشاهده خواهیم کرد که با وجود عدم استفاده از کلمه کلیدی lock یا کلاس Monitor، برنامه به صورت Thread-Safe اجرا شده و خروجی مناسب برای ما تولید می شود. در اینجا مبحث مربوط به Synchronization به اتمام رسیده و در قسمت در مورد کلاس Timer در فضای نام System.Threading صحبت خواهیم کرد.

منبع

قسمت اول آموزش-برنامه نویسی Asynchronous – آشنایی با Process ها، Thread ها و AppDomain ها

قسمت دوم آموزش- آشنایی با ماهیت Asynchronous در Delegate ها

قسمت سوم آموزش-آشنایی با فضای نام System.Threading و کلاس Thread

قسمت چهارم آموزش- آشنایی با Thread های Foreground و Background در دات نت

قسمت پنجم آموزش- آشنایی با مشکل Concurrency در برنامه های Multi-Threaded و راهکار های رفع این مشکل

قسمت ششم آموزش- آشنایی با کلاس Timer در زبان سی شارپ

قسمت هفتم آموزش-آشنایی با CLR ThreadPool در دات نت

قسمت هشتم آموزش- مقدمه ای بر Task Parallel Library و کلاس Parallel در دات نت

قسمت نهم آموزش- برنامه نویسی Parallel:آشنایی با کلاس Task در سی شارپ

قسمت دهم آموزش-برنامه نویسی Parallel در سی شارپ :: متوقف کردن Task ها در سی شارپ – کلاس CancellationToken

قسمت یازدهم آموزش- برنامه نویسی Parallel در سی شارپ :: کوئری های Parallel در LINQ

قسمت دوازدهم آموزش- آشنایی با کلمات کلیدی async و await در زبان سی شارپ

قسمت سیزدهم آموزش- استفاده از متد WhenAll برای اجرای چندین Task به صورت همزمان در سی شارپ

/0 دیدگاه /توسط

راهنمای شبکه در DVR یا انتقال تصویر دوربین

مقدمه

فعال کردن شبکه در DVR به شما این امکان را می دهد تا از طریق یک PC از راه دور برای مشاهده آنلاین یا ذخیره فیلم های موجود اقدام نمایید. DVR ها توانایی وصل شدن به شبکه داخلی و گاهی در بعضی مدل ها توانایی وصل شدن به شبکه جهانی اینترنت را دارند.
اجرای تنظیمات و اتصال به DVR می تواند از طریق سیتم عامل های مختلف صورت بپذیرد ولی تصاویر استفاده شده در این آموزش از روی یک کامپیوتر با سیستم عامل ویندوز ایکس پی تهیه شده است.

مراحل اتصال به DVR

1. آدرس آی پی (IP)، زیر شبکه(subnet mask) و دروازه پیش فرض(default gateway) کامپیوتر خود را پیدا کنید و در جدول شماره 1 یادداشت نمایید

        الف ) صفحه command prompt را باز میکنید

command prompt

شکل شماره 1

        ب ) در صفحه cmd باز شده، دستور ipconfig را تایپ کرده و اطلاعات داده شده را در جدول 1 یادداشت نمایید.

صفحه cmd

شکل شماره 2

جدول شماره 1

شکل شماره 3-جدول شماره 1

توجه داشته باشید که اطلاعات آدرس شبکه ای کامپیوتر شما ممکن است با آنچه در تصویر آمده است متفاوت باشد. همچنین در نظر داشته باشید که آدرس IP در ویندوز های Vista و 7 با عنوان IPV4 نمایش داده می شوند.

2. آدرس آی پی دستگاه DVR خود را با استفاده از راهنمای موجود در جعبه تغییر دهید.
الف ) اتصالاتDVR را برقرار کنید. (بجز اتصال کابل شبکه)
ب ) DVR را روشن کرده و از طریق setup و گزینه Network وارد تنظیمات شبکه شوید.
ج ) امکان استفاده از DHCP را روی DVR غیر فعال کنید.
د ) یک آدرس آی پی برای دستگاه DVR خود در نظر بگیرید.
A ) دقیقا آدرس آی پی کامپیوتر خود را بجز قسمت آخر یادداشت کنید. مثلا 192.168.1.
B ) برای قسمت آخر یک عدد بین 1 تا 255 انتخاب کنید. توجه کنید که این عدد باید با عدد آخر آدرس آی پی کامپیوتر شما متفاوت باشد.
C ) در صفحه cmd با استفاده از دستور ping تست کنید که آیا این آی پی در شبکه موجود می باشد یا خیر
Ping 192.168.1.عدد انتخاب شده

دستور ping

شکل شماره 4

اگر با استفاده از دستور ping پاسخ دریافتی شبیه آنچه در شکل 5 می بینید بود، یعنی آن آدرس آی پی قبلا به یک کامپیوتر دیگر در شبکه اختصاص یافته است.
اگر بعد از استفاده از دستور ping پاسخی شبیه آنچه در شکل 6 آمده است دیدید یعنی می توانید از آن آدرس برای DVR خود استفاده نمایید.

استفاده از ادرس برای DVR

شکل شماره 5

ه ) در قسمت آی پی DVR، آدرس آی پی انتخاب شده را وارد نمایید. آدرس زیر شبکه را باید دقیقا همانند آدرس زیر شبکه کامپیوتر خود انتخاب کنید.
و) بر اساس جدول موجود در دفترچه DVR و یا اطلاعات موجود روی صفحه تنظیمات شبکه DVR پورت های مربوط به DVR را مشخص نمایید.
ز ) تنظیمات را ذخیره کرده و از منوی شبکه خارج شوید.
ح) DVR را ریستارت نمایید تا تنظیمات اعمال شود.
ط ) کابل شبکه DVR را وصل نموده و روی دستگاه کامپیوتر خود صفحه cmd را باز کنید.
ی ) با استفاده از دستور ping چک کنید که آیا ارتباط با DVR برقرار است یا خیر. بایستی جواب دستور ping شبیه آنچه در شکل 7 دیده می شود، باشد.

بررسی ارتباط با DVR

شکل شماره 6

ک ) درصورتیکه ارتباط برقرار است می توانید با وارد کردن آی پی در برنامه مورد نظر روی دستگاه کامپیوتر یا دستگاه موبایل خود و دادن پورت مشخص شده در قسمت “و” ارتباط تصویری با DVR را برقرار نمایید.
ل ) درصورتیکه می خواهید از مرورگر های اینترنتی جهت اتصال و مانیتورینگ DVR استفاده نمایید کافیست مرورگر مورد نظر (IE, firefox, chrome) را باز کرده و در قسمت address bar، آی پی   DVR را وارد کرده و در انتها با یک “:” پورت را به آن معرفی نمایید.
برای مثال اگر آی پی DVR شما 192.168.1.100 است و پورت تعریف شده 92 می باشد. آدرس 192.168.1.100:92 را در مرورگر وارد نمایید.

آدرس ای پی DVR به همراه پورت

شکل شماره 7

انتقال تصاویر روی اینترنت

بعضی از DVR ها امکان انتقال تصاویر بر روی اینترنت از طریق مرورگر یا دستگاه های موبایل را دارا می باشند.
برای این منظور نیاز به یک ارتباط پرسرعت اینترنت در محل قرارگیری دستگاه DVR و یک ارتباط پرسرعت اینترنت دیگر در محلی که قرار است مانیتورینگ انجام پذیرد، وجود دارد.
برای استفاده از ویژگی انتقال تصویر بایستی port forwarding روی روتر اینترنت محل قرارگیری دستگاه DVR انجام شود.
1. با کمک اطلاعات موجود در دفترچه راهنمای روتر (مودم ADSL) خود و یا استفاده از اطلاعات وب سایت، http://portforwarding.comروتر خود را برای انجام port forwarding تنظیم نمایید.

دقت نمایید که در پروسه port forwarding شما یک پورت داخلی دارید که همان پورت مشخص شده در دستگاه DVR است و یک پورت خارجی دارید که با راهنمایی شرکت سرویس دهنده اینترنت می توانید از پورت های خالی قابل استفاده اطلاع حاصل نمایید.
همچنین لازم است تا آی پی دستگاه DVR را به عنوان آدرس دستگاهی که port forwarding روی آن انجام می شود، وارد نمایید.

2. بعد از انجام پروسه port forwarding کافیست با مراجعه به سایت www.yougetsignal.com و استفاده از ابزار port forwarding tester بررسی نمایید که آیا پروسه با موفقیت انجام شده است یا خیر.
3. با استفاده از ابزار what is my IP در وب سایت www.yougetsignal.com یا با بازکردن سایت www.whatismyip.com روی یکی از کامپیوتر های موجود در شبکه ای که دستگاه DVR هم در آن قرار دارد، شبکه خود را بدست آورید.
4. روی کامپیوتر یا دستگاه موبایل محلی که می خواهید مانیتوریگ انجام شود کافیست همانند اینکه کامپیوتر یا موبایل در همان شبکه DVR قرار دارد، عمل نمایید تنها با این تفاوت که بجای آدرس آی پی محلی که قبلا وارد کرده اید (قسمت “ل”) آدرس آی پی ای را که از سایت www.whatismyip.com بدست آورده اید وارد می کنید و بجای پورت داخلی، پورت خارجی ای که از شرکت سرویس دهنده اینترنت دریافت کرده اید وارد می نمایید.
لازم به ذکر است مرورگرهای اینترنتی بطور پیش فرض از پورت 80 استفاده می کنند که گاهی این پورت در شبکه داخلی یا شبکه اینترنت قبلا توسط نرم افزار دیگری مورد استفاده قرار گرفته یا شرکت سرویس دهنده اینترنت جهت امنیت بیشتر این پورت را بسته است.

منبع

/0 دیدگاه /توسط