Skip to content
BranchesTags

Repository files navigation

Finding Lane Lines on the Road

Cory Pruce

Finding Lane Lines on the Road

The goals / steps of this project are the following:

  • Make a pipeline that finds lane lines on the road
  • Reflect on your work in a written report

Reflection

1. Describe your pipeline. As part of the description, explain how you modified the draw_lines() function.

The pipeline laid out can be segmented into 6 parts, including writing the image to persistent storage:

defrun(self, image):
h, w, _d=image.shapepolygon_vertices=self.get_lanes_polygon(h, w)
blur_gray=gaussian_blur(grayscale(image), self.kernel_size)
edges_image=canny(blur_gray, self.canny_low, self.canny_high)
masked_image=region_of_interest(edges_image, polygon_vertices)
lanes_image=self.get_lanes_image(masked_image, image, polygon_vertices)
self.write_img(lanes_image)
returnlanes_image

Following the quizzes and a forum post, I first converted the image to grayscale, then blurring that image by sending through a Gaussian distribution. From there, I extract edges using the canny function with thresholds of 140 for lower and 145 for higher. Constrained to an adjustable trapezoid, I get the image with lanes drawn through the hough function and draw lines.

After a bit of a struggle trying to get the lane lines right using sohcahtoa, I took to the forums for inspiration (and help with getting the video to update). There I found simple uses of the polyfit/poly1d functions to find the line that best fits the given points. At this point, I already had a slope threshold so creating good lane lists was trivial. Upon acheiving a "working" solution, I noticed that the lanes had a lot of volatility (bounced off the line). Seeing another forum post, I implemented a small buffer of "memory" that saves up to eviction_threshold previous lane pairs. This smoothed the videos out incredibly! :)

2. Identify potential shortcomings with your current pipeline

One potential shortcoming would be what would happen when some object enters into the picture, literally! The given demonstrations assume an open road ahead. However, lines are not always perfect, objects like cars could be in front, and curves/angles/lighting can frequentely change.

Another shortcoming could be granularity. These lanes take the form of lines. However, lane "lines" ahead are usually not perfectly aligned with the orientation of the vehicle. Acheiving some flexibility in the "line" would probably really coincide with something like path-planning ;)

Addressing the optional challenge, I believe points being picked up on the left are skewing the lane line. I've tried removing outliers and choosing the furthest left best-fit line out of 3-5 rounds but each polyfit was seeded the same. I tried a few window sizes and shuffling. My guess is the most robust approach is random sampling n times to get the true best-fit line (I was going by highest x1 value).

3. Suggest possible improvements to your pipeline

A possible improvement would be to automate this even more with a convnet! The problem could be structured as either a supervised or unsupervised learning problem and would get the granularity issue down with enough data!

Another potential improvement could be to train on images with less-than-ideal circumstances. For example, images that contain tunnels, bridges, boats, other objects, road paint, similar looking objects (like a stop-sign bumper sticker). Maybe this last one is a bit more than just lane detection!

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

0 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - Cpruce/SDC-LaneDetection · GitHub
Skip to content
BranchesTags
Repository files navigation
Finding Lane Lines on the Road
Cory Pruce
Finding Lane Lines on the Road
The goals / steps of this project are the following:
  • Make a pipeline that finds lane lines on the road
  • Reflect on your work in a written report
Reflection
1. Describe your pipeline. As part of the description, explain how you modified the draw_lines() function.
The pipeline laid out can be segmented into 6 parts, including writing the image to persistent storage:
defrun(self, image):
h, w, _d=image.shapepolygon_vertices=self.get_lanes_polygon(h, w)
blur_gray=gaussian_blur(grayscale(image), self.kernel_size)
edges_image=canny(blur_gray, self.canny_low, self.canny_high)
masked_image=region_of_interest(edges_image, polygon_vertices)
lanes_image=self.get_lanes_image(masked_image, image, polygon_vertices)
self.write_img(lanes_image)
returnlanes_image
Following the quizzes and a forum post, I first converted the image to grayscale, then blurring that image by sending through a Gaussian distribution. From there, I extract edges using the canny function with thresholds of 140 for lower and 145 for higher. Constrained to an adjustable trapezoid, I get the image with lanes drawn through the hough function and draw lines.
After a bit of a struggle trying to get the lane lines right using sohcahtoa, I took to the forums for inspiration (and help with getting the video to update). There I found simple uses of the polyfit/poly1d functions to find the line that best fits the given points. At this point, I already had a slope threshold so creating good lane lists was trivial. Upon acheiving a "working" solution, I noticed that the lanes had a lot of volatility (bounced off the line). Seeing another forum post, I implemented a small buffer of "memory" that saves up to eviction_threshold previous lane pairs. This smoothed the videos out incredibly! :)
2. Identify potential shortcomings with your current pipeline
One potential shortcoming would be what would happen when some object enters into the picture, literally! The given demonstrations assume an open road ahead. However, lines are not always perfect, objects like cars could be in front, and curves/angles/lighting can frequentely change.
Another shortcoming could be granularity. These lanes take the form of lines. However, lane "lines" ahead are usually not perfectly aligned with the orientation of the vehicle. Acheiving some flexibility in the "line" would probably really coincide with something like path-planning ;)
Addressing the optional challenge, I believe points being picked up on the left are skewing the lane line. I've tried removing outliers and choosing the furthest left best-fit line out of 3-5 rounds but each polyfit was seeded the same. I tried a few window sizes and shuffling. My guess is the most robust approach is random sampling n times to get the true best-fit line (I was going by highest x1 value).
3. Suggest possible improvements to your pipeline
A possible improvement would be to automate this even more with a convnet! The problem could be structured as either a supervised or unsupervised learning problem and would get the granularity issue down with enough data!
Another potential improvement could be to train on images with less-than-ideal circumstances. For example, images that contain tunnels, bridges, boats, other objects, road paint, similar looking objects (like a stop-sign bumper sticker). Maybe this last one is a bit more than just lane detection!
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - Cpruce/SDC-LaneDetection · GitHub
Skip to content
BranchesTags
Repository files navigation
Finding Lane Lines on the Road
Cory Pruce
Finding Lane Lines on the Road
The goals / steps of this project are the following:
  • Make a pipeline that finds lane lines on the road
  • Reflect on your work in a written report
Reflection
1. Describe your pipeline. As part of the description, explain how you modified the draw_lines() function.
The pipeline laid out can be segmented into 6 parts, including writing the image to persistent storage:
defrun(self, image):
h, w, _d=image.shapepolygon_vertices=self.get_lanes_polygon(h, w)
blur_gray=gaussian_blur(grayscale(image), self.kernel_size)
edges_image=canny(blur_gray, self.canny_low, self.canny_high)
masked_image=region_of_interest(edges_image, polygon_vertices)
lanes_image=self.get_lanes_image(masked_image, image, polygon_vertices)
self.write_img(lanes_image)
returnlanes_image
Following the quizzes and a forum post, I first converted the image to grayscale, then blurring that image by sending through a Gaussian distribution. From there, I extract edges using the canny function with thresholds of 140 for lower and 145 for higher. Constrained to an adjustable trapezoid, I get the image with lanes drawn through the hough function and draw lines.
After a bit of a struggle trying to get the lane lines right using sohcahtoa, I took to the forums for inspiration (and help with getting the video to update). There I found simple uses of the polyfit/poly1d functions to find the line that best fits the given points. At this point, I already had a slope threshold so creating good lane lists was trivial. Upon acheiving a "working" solution, I noticed that the lanes had a lot of volatility (bounced off the line). Seeing another forum post, I implemented a small buffer of "memory" that saves up to eviction_threshold previous lane pairs. This smoothed the videos out incredibly! :)
2. Identify potential shortcomings with your current pipeline
One potential shortcoming would be what would happen when some object enters into the picture, literally! The given demonstrations assume an open road ahead. However, lines are not always perfect, objects like cars could be in front, and curves/angles/lighting can frequentely change.
Another shortcoming could be granularity. These lanes take the form of lines. However, lane "lines" ahead are usually not perfectly aligned with the orientation of the vehicle. Acheiving some flexibility in the "line" would probably really coincide with something like path-planning ;)
Addressing the optional challenge, I believe points being picked up on the left are skewing the lane line. I've tried removing outliers and choosing the furthest left best-fit line out of 3-5 rounds but each polyfit was seeded the same. I tried a few window sizes and shuffling. My guess is the most robust approach is random sampling n times to get the true best-fit line (I was going by highest x1 value).
3. Suggest possible improvements to your pipeline
A possible improvement would be to automate this even more with a convnet! The problem could be structured as either a supervised or unsupervised learning problem and would get the granularity issue down with enough data!
Another potential improvement could be to train on images with less-than-ideal circumstances. For example, images that contain tunnels, bridges, boats, other objects, road paint, similar looking objects (like a stop-sign bumper sticker). Maybe this last one is a bit more than just lane detection!
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - Cpruce/SDC-LaneDetection · GitHub
Skip to content
BranchesTags
Repository files navigation
Finding Lane Lines on the Road
Cory Pruce
Finding Lane Lines on the Road
The goals / steps of this project are the following:
  • Make a pipeline that finds lane lines on the road
  • Reflect on your work in a written report
Reflection
1. Describe your pipeline. As part of the description, explain how you modified the draw_lines() function.
The pipeline laid out can be segmented into 6 parts, including writing the image to persistent storage:
defrun(self, image):
h, w, _d=image.shapepolygon_vertices=self.get_lanes_polygon(h, w)
blur_gray=gaussian_blur(grayscale(image), self.kernel_size)
edges_image=canny(blur_gray, self.canny_low, self.canny_high)
masked_image=region_of_interest(edges_image, polygon_vertices)
lanes_image=self.get_lanes_image(masked_image, image, polygon_vertices)
self.write_img(lanes_image)
returnlanes_image
Following the quizzes and a forum post, I first converted the image to grayscale, then blurring that image by sending through a Gaussian distribution. From there, I extract edges using the canny function with thresholds of 140 for lower and 145 for higher. Constrained to an adjustable trapezoid, I get the image with lanes drawn through the hough function and draw lines.
After a bit of a struggle trying to get the lane lines right using sohcahtoa, I took to the forums for inspiration (and help with getting the video to update). There I found simple uses of the polyfit/poly1d functions to find the line that best fits the given points. At this point, I already had a slope threshold so creating good lane lists was trivial. Upon acheiving a "working" solution, I noticed that the lanes had a lot of volatility (bounced off the line). Seeing another forum post, I implemented a small buffer of "memory" that saves up to eviction_threshold previous lane pairs. This smoothed the videos out incredibly! :)
2. Identify potential shortcomings with your current pipeline
One potential shortcoming would be what would happen when some object enters into the picture, literally! The given demonstrations assume an open road ahead. However, lines are not always perfect, objects like cars could be in front, and curves/angles/lighting can frequentely change.
Another shortcoming could be granularity. These lanes take the form of lines. However, lane "lines" ahead are usually not perfectly aligned with the orientation of the vehicle. Acheiving some flexibility in the "line" would probably really coincide with something like path-planning ;)
Addressing the optional challenge, I believe points being picked up on the left are skewing the lane line. I've tried removing outliers and choosing the furthest left best-fit line out of 3-5 rounds but each polyfit was seeded the same. I tried a few window sizes and shuffling. My guess is the most robust approach is random sampling n times to get the true best-fit line (I was going by highest x1 value).
3. Suggest possible improvements to your pipeline
A possible improvement would be to automate this even more with a convnet! The problem could be structured as either a supervised or unsupervised learning problem and would get the granularity issue down with enough data!
Another potential improvement could be to train on images with less-than-ideal circumstances. For example, images that contain tunnels, bridges, boats, other objects, road paint, similar looking objects (like a stop-sign bumper sticker). Maybe this last one is a bit more than just lane detection!
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - Cpruce/SDC-LaneDetection · GitHub
Skip to content
BranchesTags
Repository files navigation
Finding Lane Lines on the Road
Cory Pruce
Finding Lane Lines on the Road
The goals / steps of this project are the following:
  • Make a pipeline that finds lane lines on the road
  • Reflect on your work in a written report
Reflection
1. Describe your pipeline. As part of the description, explain how you modified the draw_lines() function.
The pipeline laid out can be segmented into 6 parts, including writing the image to persistent storage:
defrun(self, image):
h, w, _d=image.shapepolygon_vertices=self.get_lanes_polygon(h, w)
blur_gray=gaussian_blur(grayscale(image), self.kernel_size)
edges_image=canny(blur_gray, self.canny_low, self.canny_high)
masked_image=region_of_interest(edges_image, polygon_vertices)
lanes_image=self.get_lanes_image(masked_image, image, polygon_vertices)
self.write_img(lanes_image)
returnlanes_image
Following the quizzes and a forum post, I first converted the image to grayscale, then blurring that image by sending through a Gaussian distribution. From there, I extract edges using the canny function with thresholds of 140 for lower and 145 for higher. Constrained to an adjustable trapezoid, I get the image with lanes drawn through the hough function and draw lines.
After a bit of a struggle trying to get the lane lines right using sohcahtoa, I took to the forums for inspiration (and help with getting the video to update). There I found simple uses of the polyfit/poly1d functions to find the line that best fits the given points. At this point, I already had a slope threshold so creating good lane lists was trivial. Upon acheiving a "working" solution, I noticed that the lanes had a lot of volatility (bounced off the line). Seeing another forum post, I implemented a small buffer of "memory" that saves up to eviction_threshold previous lane pairs. This smoothed the videos out incredibly! :)
2. Identify potential shortcomings with your current pipeline
One potential shortcoming would be what would happen when some object enters into the picture, literally! The given demonstrations assume an open road ahead. However, lines are not always perfect, objects like cars could be in front, and curves/angles/lighting can frequentely change.
Another shortcoming could be granularity. These lanes take the form of lines. However, lane "lines" ahead are usually not perfectly aligned with the orientation of the vehicle. Acheiving some flexibility in the "line" would probably really coincide with something like path-planning ;)
Addressing the optional challenge, I believe points being picked up on the left are skewing the lane line. I've tried removing outliers and choosing the furthest left best-fit line out of 3-5 rounds but each polyfit was seeded the same. I tried a few window sizes and shuffling. My guess is the most robust approach is random sampling n times to get the true best-fit line (I was going by highest x1 value).
3. Suggest possible improvements to your pipeline
A possible improvement would be to automate this even more with a convnet! The problem could be structured as either a supervised or unsupervised learning problem and would get the granularity issue down with enough data!
Another potential improvement could be to train on images with less-than-ideal circumstances. For example, images that contain tunnels, bridges, boats, other objects, road paint, similar looking objects (like a stop-sign bumper sticker). Maybe this last one is a bit more than just lane detection!
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - Cpruce/SDC-LaneDetection · GitHub
Skip to content
BranchesTags
Repository files navigation
Finding Lane Lines on the Road
Cory Pruce
Finding Lane Lines on the Road
The goals / steps of this project are the following:
  • Make a pipeline that finds lane lines on the road
  • Reflect on your work in a written report
Reflection
1. Describe your pipeline. As part of the description, explain how you modified the draw_lines() function.
The pipeline laid out can be segmented into 6 parts, including writing the image to persistent storage:
defrun(self, image):
h, w, _d=image.shapepolygon_vertices=self.get_lanes_polygon(h, w)
blur_gray=gaussian_blur(grayscale(image), self.kernel_size)
edges_image=canny(blur_gray, self.canny_low, self.canny_high)
masked_image=region_of_interest(edges_image, polygon_vertices)
lanes_image=self.get_lanes_image(masked_image, image, polygon_vertices)
self.write_img(lanes_image)
returnlanes_image
Following the quizzes and a forum post, I first converted the image to grayscale, then blurring that image by sending through a Gaussian distribution. From there, I extract edges using the canny function with thresholds of 140 for lower and 145 for higher. Constrained to an adjustable trapezoid, I get the image with lanes drawn through the hough function and draw lines.
After a bit of a struggle trying to get the lane lines right using sohcahtoa, I took to the forums for inspiration (and help with getting the video to update). There I found simple uses of the polyfit/poly1d functions to find the line that best fits the given points. At this point, I already had a slope threshold so creating good lane lists was trivial. Upon acheiving a "working" solution, I noticed that the lanes had a lot of volatility (bounced off the line). Seeing another forum post, I implemented a small buffer of "memory" that saves up to eviction_threshold previous lane pairs. This smoothed the videos out incredibly! :)
2. Identify potential shortcomings with your current pipeline
One potential shortcoming would be what would happen when some object enters into the picture, literally! The given demonstrations assume an open road ahead. However, lines are not always perfect, objects like cars could be in front, and curves/angles/lighting can frequentely change.
Another shortcoming could be granularity. These lanes take the form of lines. However, lane "lines" ahead are usually not perfectly aligned with the orientation of the vehicle. Acheiving some flexibility in the "line" would probably really coincide with something like path-planning ;)
Addressing the optional challenge, I believe points being picked up on the left are skewing the lane line. I've tried removing outliers and choosing the furthest left best-fit line out of 3-5 rounds but each polyfit was seeded the same. I tried a few window sizes and shuffling. My guess is the most robust approach is random sampling n times to get the true best-fit line (I was going by highest x1 value).
3. Suggest possible improvements to your pipeline
A possible improvement would be to automate this even more with a convnet! The problem could be structured as either a supervised or unsupervised learning problem and would get the granularity issue down with enough data!
Another potential improvement could be to train on images with less-than-ideal circumstances. For example, images that contain tunnels, bridges, boats, other objects, road paint, similar looking objects (like a stop-sign bumper sticker). Maybe this last one is a bit more than just lane detection!
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - Cpruce/SDC-LaneDetection · GitHub
Skip to content
BranchesTags
Repository files navigation
Finding Lane Lines on the Road
Cory Pruce
Finding Lane Lines on the Road
The goals / steps of this project are the following:
  • Make a pipeline that finds lane lines on the road
  • Reflect on your work in a written report
Reflection
1. Describe your pipeline. As part of the description, explain how you modified the draw_lines() function.
The pipeline laid out can be segmented into 6 parts, including writing the image to persistent storage:
defrun(self, image):
h, w, _d=image.shapepolygon_vertices=self.get_lanes_polygon(h, w)
blur_gray=gaussian_blur(grayscale(image), self.kernel_size)
edges_image=canny(blur_gray, self.canny_low, self.canny_high)
masked_image=region_of_interest(edges_image, polygon_vertices)
lanes_image=self.get_lanes_image(masked_image, image, polygon_vertices)
self.write_img(lanes_image)
returnlanes_image
Following the quizzes and a forum post, I first converted the image to grayscale, then blurring that image by sending through a Gaussian distribution. From there, I extract edges using the canny function with thresholds of 140 for lower and 145 for higher. Constrained to an adjustable trapezoid, I get the image with lanes drawn through the hough function and draw lines.
After a bit of a struggle trying to get the lane lines right using sohcahtoa, I took to the forums for inspiration (and help with getting the video to update). There I found simple uses of the polyfit/poly1d functions to find the line that best fits the given points. At this point, I already had a slope threshold so creating good lane lists was trivial. Upon acheiving a "working" solution, I noticed that the lanes had a lot of volatility (bounced off the line). Seeing another forum post, I implemented a small buffer of "memory" that saves up to eviction_threshold previous lane pairs. This smoothed the videos out incredibly! :)
2. Identify potential shortcomings with your current pipeline
One potential shortcoming would be what would happen when some object enters into the picture, literally! The given demonstrations assume an open road ahead. However, lines are not always perfect, objects like cars could be in front, and curves/angles/lighting can frequentely change.
Another shortcoming could be granularity. These lanes take the form of lines. However, lane "lines" ahead are usually not perfectly aligned with the orientation of the vehicle. Acheiving some flexibility in the "line" would probably really coincide with something like path-planning ;)
Addressing the optional challenge, I believe points being picked up on the left are skewing the lane line. I've tried removing outliers and choosing the furthest left best-fit line out of 3-5 rounds but each polyfit was seeded the same. I tried a few window sizes and shuffling. My guess is the most robust approach is random sampling n times to get the true best-fit line (I was going by highest x1 value).
3. Suggest possible improvements to your pipeline
A possible improvement would be to automate this even more with a convnet! The problem could be structured as either a supervised or unsupervised learning problem and would get the granularity issue down with enough data!
Another potential improvement could be to train on images with less-than-ideal circumstances. For example, images that contain tunnels, bridges, boats, other objects, road paint, similar looking objects (like a stop-sign bumper sticker). Maybe this last one is a bit more than just lane detection!
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - Cpruce/SDC-LaneDetection · GitHub
Skip to content
BranchesTags
Repository files navigation
Finding Lane Lines on the Road
Cory Pruce
Finding Lane Lines on the Road
The goals / steps of this project are the following:
  • Make a pipeline that finds lane lines on the road
  • Reflect on your work in a written report
Reflection
1. Describe your pipeline. As part of the description, explain how you modified the draw_lines() function.
The pipeline laid out can be segmented into 6 parts, including writing the image to persistent storage:
defrun(self, image):
h, w, _d=image.shapepolygon_vertices=self.get_lanes_polygon(h, w)
blur_gray=gaussian_blur(grayscale(image), self.kernel_size)
edges_image=canny(blur_gray, self.canny_low, self.canny_high)
masked_image=region_of_interest(edges_image, polygon_vertices)
lanes_image=self.get_lanes_image(masked_image, image, polygon_vertices)
self.write_img(lanes_image)
returnlanes_image
Following the quizzes and a forum post, I first converted the image to grayscale, then blurring that image by sending through a Gaussian distribution. From there, I extract edges using the canny function with thresholds of 140 for lower and 145 for higher. Constrained to an adjustable trapezoid, I get the image with lanes drawn through the hough function and draw lines.
After a bit of a struggle trying to get the lane lines right using sohcahtoa, I took to the forums for inspiration (and help with getting the video to update). There I found simple uses of the polyfit/poly1d functions to find the line that best fits the given points. At this point, I already had a slope threshold so creating good lane lists was trivial. Upon acheiving a "working" solution, I noticed that the lanes had a lot of volatility (bounced off the line). Seeing another forum post, I implemented a small buffer of "memory" that saves up to eviction_threshold previous lane pairs. This smoothed the videos out incredibly! :)
2. Identify potential shortcomings with your current pipeline
One potential shortcoming would be what would happen when some object enters into the picture, literally! The given demonstrations assume an open road ahead. However, lines are not always perfect, objects like cars could be in front, and curves/angles/lighting can frequentely change.
Another shortcoming could be granularity. These lanes take the form of lines. However, lane "lines" ahead are usually not perfectly aligned with the orientation of the vehicle. Acheiving some flexibility in the "line" would probably really coincide with something like path-planning ;)
Addressing the optional challenge, I believe points being picked up on the left are skewing the lane line. I've tried removing outliers and choosing the furthest left best-fit line out of 3-5 rounds but each polyfit was seeded the same. I tried a few window sizes and shuffling. My guess is the most robust approach is random sampling n times to get the true best-fit line (I was going by highest x1 value).
3. Suggest possible improvements to your pipeline
A possible improvement would be to automate this even more with a convnet! The problem could be structured as either a supervised or unsupervised learning problem and would get the granularity issue down with enough data!
Another potential improvement could be to train on images with less-than-ideal circumstances. For example, images that contain tunnels, bridges, boats, other objects, road paint, similar looking objects (like a stop-sign bumper sticker). Maybe this last one is a bit more than just lane detection!
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages