Skip to content
BranchesTags

Repository files navigation

CanonWebAPI

⚠️ BETA SOFTWARE: This project is currently in beta stage. While functional, it may contain bugs and is subject to breaking changes. Use with caution in production environments.

A web API for remotely controlling Canon DSLR and mirrorless cameras. This project utilizes the Canon EDSDK to communicate with the camera and includes automatic update capabilities.

Features

  • Get camera information (e.g., camera name).
  • Get and set camera settings:
    • ISO Speed
    • Aperture
    • Shutter Speed
    • Exposure Compensation
    • White Balance
  • Take pictures and download them.
  • Live view streaming via MJPEG.
  • Trigger autofocus.
  • Retrieve the last taken picture from the camera.
  • Automatic updates via AutoUpdater.NET integration.
  • Version display in console on startup.

Project Structure

The solution is divided into the following projects:

  • Canon.API: An ASP.NET Core web application that exposes the camera controls as a RESTful API.
  • Canon.Core: A .NET library that wraps the Canon EDSDK, providing a higher-level interface to interact with the camera.
  • Canon.Test: A simple console application for testing the Canon.Core library.
  • Canon.Test.Avalonia: A desktop application built with Avalonia UI for testing camera functionalities.
  • EDSDK: Contains the necessary Canon EDSDK libraries (EDSDK.dll, EdsImage.dll).

Getting Started

Prerequisites

  • A compatible Canon camera (tested with Canon EOS R100 and Canon T7).
  • The camera connected to the computer via USB.
  • .NET 9 SDK (or newer).
  • The Canon EOS Utility software should not be running, as it can prevent this application from connecting to the camera.
  • Windows operating system (x64 architecture required).

Installation

  1. Clone this repository.
  2. Ensure the EDSDK folder, containing EDSDK.dll and EdsImage.dll, is present in the project's root directory. These files are essential for the Canon.Core library to communicate with the camera.
  3. Build the solution using Visual Studio or the dotnet build command.
  4. Run the Canon.API project. This will start the web server.

API Endpoints

The following endpoints are available once the Canon.API project is running:

MethodPathDescriptionRequest Body (Example)
GET/cameranameGets the connected camera's name.N/A
GET/isoGets the current ISO speed and a list of supported values.N/A
POST/isoSets the ISO speed.{"value": "100"}
GET/apertureGets the current aperture and a list of supported values.N/A
POST/apertureSets the aperture.{"value": "5.6"}
GET/shutterspeedGets the current shutter speed and a list of supported values.N/A
POST/shutterspeedSets the shutter speed.{"value": "1/125"}
GET/exposureGets the current exposure compensation and supported values.N/A
POST/exposureSets the exposure compensation.{"value": "+1"}
GET/whitebalanceGets the current white balance and supported values.N/A
POST/whitebalanceSets the white balance.{"value": "Auto"}
POST/takepictureTakes a picture and returns the JPEG image. The useAutoFocus query parameter (default true) can be used to control autofocus.N/A
GET/videostreamStarts an MJPEG live view stream.N/A
GET/latestpictureGets the last picture taken from the camera's memory.N/A
POST/autofocusTriggers the camera's autofocus mechanism.N/A

Automatic Updates

This application includes automatic update functionality powered by AutoUpdater.NET:

  • Automatic version checking on startup
  • Seamless updates without requiring admin privileges
  • Graceful shutdown handling for web server during updates
  • Updates are downloaded from GitHub releases automatically

Development & Building

Building from Source

# Clone the repository
git clone https://github.com/dansleboby/CanonWebAPI.git
cd CanonWebAPI
# Restore dependencies
dotnet restore CanonSDK.sln
# Build the solution
dotnet build CanonSDK.sln --configuration Release
# Run the API
dotnet run --project Canon.API

Creating Releases

This project uses automated GitHub Actions for releases:

  1. Tag-based releases: Push a tag like v1.0.0.9 to trigger automated build and release
  2. Version synchronization: The workflow automatically updates project versions to match the tag
  3. Automatic packaging: Creates release packages and updates the AutoUpdater XML
  4. GitHub releases: Automatically creates GitHub releases with generated notes

Running Different Projects

# Run the Web API
dotnet run --project Canon.API
# Run the Console Test Application 
dotnet run --project Canon.Test
# Run the Avalonia GUI Test Application
dotnet run --project Canon.Test.Avalonia

Compatibility

Tested Camera Models

  • Canon EOS R100 ✅
  • Canon T7 ✅

System Requirements

  • OS: Windows (x64)
  • Runtime: .NET 9 or newer
  • Dependencies: Canon EDSDK libraries (included)

Note: While this software has been tested with the above camera models, it should work with other Canon cameras that support the EDSDK. However, functionality may vary depending on the specific camera model and its supported features.

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

3 stars

Watchers

0 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 - dansleboby/CanonWebAPI · GitHub
Skip to content
BranchesTags
Repository files navigation
CanonWebAPI
⚠️ BETA SOFTWARE: This project is currently in beta stage. While functional, it may contain bugs and is subject to breaking changes. Use with caution in production environments.
A web API for remotely controlling Canon DSLR and mirrorless cameras. This project utilizes the Canon EDSDK to communicate with the camera and includes automatic update capabilities.
Features
  • Get camera information (e.g., camera name).
  • Get and set camera settings:

    • ISO Speed
    • Aperture
    • Shutter Speed
    • Exposure Compensation
    • White Balance
  • Take pictures and download them.
  • Live view streaming via MJPEG.
  • Trigger autofocus.
  • Retrieve the last taken picture from the camera.
  • Automatic updates via AutoUpdater.NET integration.
  • Version display in console on startup.
Project Structure
The solution is divided into the following projects:
  • Canon.API: An ASP.NET Core web application that exposes the camera controls as a RESTful API.
  • Canon.Core: A .NET library that wraps the Canon EDSDK, providing a higher-level interface to interact with the camera.
  • Canon.Test: A simple console application for testing the Canon.Core library.
  • Canon.Test.Avalonia: A desktop application built with Avalonia UI for testing camera functionalities.
  • EDSDK: Contains the necessary Canon EDSDK libraries (EDSDK.dll, EdsImage.dll).
Getting Started
Prerequisites
  • A compatible Canon camera (tested with Canon EOS R100 and Canon T7).
  • The camera connected to the computer via USB.
  • .NET 9 SDK (or newer).
  • The Canon EOS Utility software should not be running, as it can prevent this application from connecting to the camera.
  • Windows operating system (x64 architecture required).
Installation
  1. Clone this repository.
  2. Ensure the EDSDK folder, containing EDSDK.dll and EdsImage.dll, is present in the project's root directory. These files are essential for the Canon.Core library to communicate with the camera.
  3. Build the solution using Visual Studio or the dotnet build command.
  4. Run the Canon.API project. This will start the web server.
API Endpoints
The following endpoints are available once the Canon.API project is running:
MethodPathDescriptionRequest Body (Example)
GET/cameranameGets the connected camera's name.N/A
GET/isoGets the current ISO speed and a list of supported values.N/A
POST/isoSets the ISO speed.{"value": "100"}
GET/apertureGets the current aperture and a list of supported values.N/A
POST/apertureSets the aperture.{"value": "5.6"}
GET/shutterspeedGets the current shutter speed and a list of supported values.N/A
POST/shutterspeedSets the shutter speed.{"value": "1/125"}
GET/exposureGets the current exposure compensation and supported values.N/A
POST/exposureSets the exposure compensation.{"value": "+1"}
GET/whitebalanceGets the current white balance and supported values.N/A
POST/whitebalanceSets the white balance.{"value": "Auto"}
POST/takepictureTakes a picture and returns the JPEG image. The useAutoFocus query parameter (default true) can be used to control autofocus.N/A
GET/videostreamStarts an MJPEG live view stream.N/A
GET/latestpictureGets the last picture taken from the camera's memory.N/A
POST/autofocusTriggers the camera's autofocus mechanism.N/A
Automatic Updates
This application includes automatic update functionality powered by AutoUpdater.NET:
  • Automatic version checking on startup
  • Seamless updates without requiring admin privileges
  • Graceful shutdown handling for web server during updates
  • Updates are downloaded from GitHub releases automatically
Development & Building
Building from Source
# Clone the repository
git clone https://github.com/dansleboby/CanonWebAPI.git
cd CanonWebAPI
# Restore dependencies
dotnet restore CanonSDK.sln
# Build the solution
dotnet build CanonSDK.sln --configuration Release
# Run the API
dotnet run --project Canon.API
Creating Releases
This project uses automated GitHub Actions for releases:
  1. Tag-based releases: Push a tag like v1.0.0.9 to trigger automated build and release
  2. Version synchronization: The workflow automatically updates project versions to match the tag
  3. Automatic packaging: Creates release packages and updates the AutoUpdater XML
  4. GitHub releases: Automatically creates GitHub releases with generated notes
Running Different Projects
# Run the Web API
dotnet run --project Canon.API
# Run the Console Test Application 
dotnet run --project Canon.Test
# Run the Avalonia GUI Test Application
dotnet run --project Canon.Test.Avalonia
Compatibility
Tested Camera Models
  • Canon EOS R100 ✅
  • Canon T7 ✅
System Requirements
  • OS: Windows (x64)
  • Runtime: .NET 9 or newer
  • Dependencies: Canon EDSDK libraries (included)
Note: While this software has been tested with the above camera models, it should work with other Canon cameras that support the EDSDK. However, functionality may vary depending on the specific camera model and its supported features.
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
3 stars
Watchers
0 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 - dansleboby/CanonWebAPI · GitHub
Skip to content
BranchesTags
Repository files navigation
CanonWebAPI
⚠️ BETA SOFTWARE: This project is currently in beta stage. While functional, it may contain bugs and is subject to breaking changes. Use with caution in production environments.
A web API for remotely controlling Canon DSLR and mirrorless cameras. This project utilizes the Canon EDSDK to communicate with the camera and includes automatic update capabilities.
Features
  • Get camera information (e.g., camera name).
  • Get and set camera settings:

    • ISO Speed
    • Aperture
    • Shutter Speed
    • Exposure Compensation
    • White Balance
  • Take pictures and download them.
  • Live view streaming via MJPEG.
  • Trigger autofocus.
  • Retrieve the last taken picture from the camera.
  • Automatic updates via AutoUpdater.NET integration.
  • Version display in console on startup.
Project Structure
The solution is divided into the following projects:
  • Canon.API: An ASP.NET Core web application that exposes the camera controls as a RESTful API.
  • Canon.Core: A .NET library that wraps the Canon EDSDK, providing a higher-level interface to interact with the camera.
  • Canon.Test: A simple console application for testing the Canon.Core library.
  • Canon.Test.Avalonia: A desktop application built with Avalonia UI for testing camera functionalities.
  • EDSDK: Contains the necessary Canon EDSDK libraries (EDSDK.dll, EdsImage.dll).
Getting Started
Prerequisites
  • A compatible Canon camera (tested with Canon EOS R100 and Canon T7).
  • The camera connected to the computer via USB.
  • .NET 9 SDK (or newer).
  • The Canon EOS Utility software should not be running, as it can prevent this application from connecting to the camera.
  • Windows operating system (x64 architecture required).
Installation
  1. Clone this repository.
  2. Ensure the EDSDK folder, containing EDSDK.dll and EdsImage.dll, is present in the project's root directory. These files are essential for the Canon.Core library to communicate with the camera.
  3. Build the solution using Visual Studio or the dotnet build command.
  4. Run the Canon.API project. This will start the web server.
API Endpoints
The following endpoints are available once the Canon.API project is running:
MethodPathDescriptionRequest Body (Example)
GET/cameranameGets the connected camera's name.N/A
GET/isoGets the current ISO speed and a list of supported values.N/A
POST/isoSets the ISO speed.{"value": "100"}
GET/apertureGets the current aperture and a list of supported values.N/A
POST/apertureSets the aperture.{"value": "5.6"}
GET/shutterspeedGets the current shutter speed and a list of supported values.N/A
POST/shutterspeedSets the shutter speed.{"value": "1/125"}
GET/exposureGets the current exposure compensation and supported values.N/A
POST/exposureSets the exposure compensation.{"value": "+1"}
GET/whitebalanceGets the current white balance and supported values.N/A
POST/whitebalanceSets the white balance.{"value": "Auto"}
POST/takepictureTakes a picture and returns the JPEG image. The useAutoFocus query parameter (default true) can be used to control autofocus.N/A
GET/videostreamStarts an MJPEG live view stream.N/A
GET/latestpictureGets the last picture taken from the camera's memory.N/A
POST/autofocusTriggers the camera's autofocus mechanism.N/A
Automatic Updates
This application includes automatic update functionality powered by AutoUpdater.NET:
  • Automatic version checking on startup
  • Seamless updates without requiring admin privileges
  • Graceful shutdown handling for web server during updates
  • Updates are downloaded from GitHub releases automatically
Development & Building
Building from Source
# Clone the repository
git clone https://github.com/dansleboby/CanonWebAPI.git
cd CanonWebAPI
# Restore dependencies
dotnet restore CanonSDK.sln
# Build the solution
dotnet build CanonSDK.sln --configuration Release
# Run the API
dotnet run --project Canon.API
Creating Releases
This project uses automated GitHub Actions for releases:
  1. Tag-based releases: Push a tag like v1.0.0.9 to trigger automated build and release
  2. Version synchronization: The workflow automatically updates project versions to match the tag
  3. Automatic packaging: Creates release packages and updates the AutoUpdater XML
  4. GitHub releases: Automatically creates GitHub releases with generated notes
Running Different Projects
# Run the Web API
dotnet run --project Canon.API
# Run the Console Test Application 
dotnet run --project Canon.Test
# Run the Avalonia GUI Test Application
dotnet run --project Canon.Test.Avalonia
Compatibility
Tested Camera Models
  • Canon EOS R100 ✅
  • Canon T7 ✅
System Requirements
  • OS: Windows (x64)
  • Runtime: .NET 9 or newer
  • Dependencies: Canon EDSDK libraries (included)
Note: While this software has been tested with the above camera models, it should work with other Canon cameras that support the EDSDK. However, functionality may vary depending on the specific camera model and its supported features.
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
3 stars
Watchers
0 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 - dansleboby/CanonWebAPI · GitHub
Skip to content
BranchesTags
Repository files navigation
CanonWebAPI
⚠️ BETA SOFTWARE: This project is currently in beta stage. While functional, it may contain bugs and is subject to breaking changes. Use with caution in production environments.
A web API for remotely controlling Canon DSLR and mirrorless cameras. This project utilizes the Canon EDSDK to communicate with the camera and includes automatic update capabilities.
Features
  • Get camera information (e.g., camera name).
  • Get and set camera settings:

    • ISO Speed
    • Aperture
    • Shutter Speed
    • Exposure Compensation
    • White Balance
  • Take pictures and download them.
  • Live view streaming via MJPEG.
  • Trigger autofocus.
  • Retrieve the last taken picture from the camera.
  • Automatic updates via AutoUpdater.NET integration.
  • Version display in console on startup.
Project Structure
The solution is divided into the following projects:
  • Canon.API: An ASP.NET Core web application that exposes the camera controls as a RESTful API.
  • Canon.Core: A .NET library that wraps the Canon EDSDK, providing a higher-level interface to interact with the camera.
  • Canon.Test: A simple console application for testing the Canon.Core library.
  • Canon.Test.Avalonia: A desktop application built with Avalonia UI for testing camera functionalities.
  • EDSDK: Contains the necessary Canon EDSDK libraries (EDSDK.dll, EdsImage.dll).
Getting Started
Prerequisites
  • A compatible Canon camera (tested with Canon EOS R100 and Canon T7).
  • The camera connected to the computer via USB.
  • .NET 9 SDK (or newer).
  • The Canon EOS Utility software should not be running, as it can prevent this application from connecting to the camera.
  • Windows operating system (x64 architecture required).
Installation
  1. Clone this repository.
  2. Ensure the EDSDK folder, containing EDSDK.dll and EdsImage.dll, is present in the project's root directory. These files are essential for the Canon.Core library to communicate with the camera.
  3. Build the solution using Visual Studio or the dotnet build command.
  4. Run the Canon.API project. This will start the web server.
API Endpoints
The following endpoints are available once the Canon.API project is running:
MethodPathDescriptionRequest Body (Example)
GET/cameranameGets the connected camera's name.N/A
GET/isoGets the current ISO speed and a list of supported values.N/A
POST/isoSets the ISO speed.{"value": "100"}
GET/apertureGets the current aperture and a list of supported values.N/A
POST/apertureSets the aperture.{"value": "5.6"}
GET/shutterspeedGets the current shutter speed and a list of supported values.N/A
POST/shutterspeedSets the shutter speed.{"value": "1/125"}
GET/exposureGets the current exposure compensation and supported values.N/A
POST/exposureSets the exposure compensation.{"value": "+1"}
GET/whitebalanceGets the current white balance and supported values.N/A
POST/whitebalanceSets the white balance.{"value": "Auto"}
POST/takepictureTakes a picture and returns the JPEG image. The useAutoFocus query parameter (default true) can be used to control autofocus.N/A
GET/videostreamStarts an MJPEG live view stream.N/A
GET/latestpictureGets the last picture taken from the camera's memory.N/A
POST/autofocusTriggers the camera's autofocus mechanism.N/A
Automatic Updates
This application includes automatic update functionality powered by AutoUpdater.NET:
  • Automatic version checking on startup
  • Seamless updates without requiring admin privileges
  • Graceful shutdown handling for web server during updates
  • Updates are downloaded from GitHub releases automatically
Development & Building
Building from Source
# Clone the repository
git clone https://github.com/dansleboby/CanonWebAPI.git
cd CanonWebAPI
# Restore dependencies
dotnet restore CanonSDK.sln
# Build the solution
dotnet build CanonSDK.sln --configuration Release
# Run the API
dotnet run --project Canon.API
Creating Releases
This project uses automated GitHub Actions for releases:
  1. Tag-based releases: Push a tag like v1.0.0.9 to trigger automated build and release
  2. Version synchronization: The workflow automatically updates project versions to match the tag
  3. Automatic packaging: Creates release packages and updates the AutoUpdater XML
  4. GitHub releases: Automatically creates GitHub releases with generated notes
Running Different Projects
# Run the Web API
dotnet run --project Canon.API
# Run the Console Test Application 
dotnet run --project Canon.Test
# Run the Avalonia GUI Test Application
dotnet run --project Canon.Test.Avalonia
Compatibility
Tested Camera Models
  • Canon EOS R100 ✅
  • Canon T7 ✅
System Requirements
  • OS: Windows (x64)
  • Runtime: .NET 9 or newer
  • Dependencies: Canon EDSDK libraries (included)
Note: While this software has been tested with the above camera models, it should work with other Canon cameras that support the EDSDK. However, functionality may vary depending on the specific camera model and its supported features.
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
3 stars
Watchers
0 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 - dansleboby/CanonWebAPI · GitHub
Skip to content
BranchesTags
Repository files navigation
CanonWebAPI
⚠️ BETA SOFTWARE: This project is currently in beta stage. While functional, it may contain bugs and is subject to breaking changes. Use with caution in production environments.
A web API for remotely controlling Canon DSLR and mirrorless cameras. This project utilizes the Canon EDSDK to communicate with the camera and includes automatic update capabilities.
Features
  • Get camera information (e.g., camera name).
  • Get and set camera settings:

    • ISO Speed
    • Aperture
    • Shutter Speed
    • Exposure Compensation
    • White Balance
  • Take pictures and download them.
  • Live view streaming via MJPEG.
  • Trigger autofocus.
  • Retrieve the last taken picture from the camera.
  • Automatic updates via AutoUpdater.NET integration.
  • Version display in console on startup.
Project Structure
The solution is divided into the following projects:
  • Canon.API: An ASP.NET Core web application that exposes the camera controls as a RESTful API.
  • Canon.Core: A .NET library that wraps the Canon EDSDK, providing a higher-level interface to interact with the camera.
  • Canon.Test: A simple console application for testing the Canon.Core library.
  • Canon.Test.Avalonia: A desktop application built with Avalonia UI for testing camera functionalities.
  • EDSDK: Contains the necessary Canon EDSDK libraries (EDSDK.dll, EdsImage.dll).
Getting Started
Prerequisites
  • A compatible Canon camera (tested with Canon EOS R100 and Canon T7).
  • The camera connected to the computer via USB.
  • .NET 9 SDK (or newer).
  • The Canon EOS Utility software should not be running, as it can prevent this application from connecting to the camera.
  • Windows operating system (x64 architecture required).
Installation
  1. Clone this repository.
  2. Ensure the EDSDK folder, containing EDSDK.dll and EdsImage.dll, is present in the project's root directory. These files are essential for the Canon.Core library to communicate with the camera.
  3. Build the solution using Visual Studio or the dotnet build command.
  4. Run the Canon.API project. This will start the web server.
API Endpoints
The following endpoints are available once the Canon.API project is running:
MethodPathDescriptionRequest Body (Example)
GET/cameranameGets the connected camera's name.N/A
GET/isoGets the current ISO speed and a list of supported values.N/A
POST/isoSets the ISO speed.{"value": "100"}
GET/apertureGets the current aperture and a list of supported values.N/A
POST/apertureSets the aperture.{"value": "5.6"}
GET/shutterspeedGets the current shutter speed and a list of supported values.N/A
POST/shutterspeedSets the shutter speed.{"value": "1/125"}
GET/exposureGets the current exposure compensation and supported values.N/A
POST/exposureSets the exposure compensation.{"value": "+1"}
GET/whitebalanceGets the current white balance and supported values.N/A
POST/whitebalanceSets the white balance.{"value": "Auto"}
POST/takepictureTakes a picture and returns the JPEG image. The useAutoFocus query parameter (default true) can be used to control autofocus.N/A
GET/videostreamStarts an MJPEG live view stream.N/A
GET/latestpictureGets the last picture taken from the camera's memory.N/A
POST/autofocusTriggers the camera's autofocus mechanism.N/A
Automatic Updates
This application includes automatic update functionality powered by AutoUpdater.NET:
  • Automatic version checking on startup
  • Seamless updates without requiring admin privileges
  • Graceful shutdown handling for web server during updates
  • Updates are downloaded from GitHub releases automatically
Development & Building
Building from Source
# Clone the repository
git clone https://github.com/dansleboby/CanonWebAPI.git
cd CanonWebAPI
# Restore dependencies
dotnet restore CanonSDK.sln
# Build the solution
dotnet build CanonSDK.sln --configuration Release
# Run the API
dotnet run --project Canon.API
Creating Releases
This project uses automated GitHub Actions for releases:
  1. Tag-based releases: Push a tag like v1.0.0.9 to trigger automated build and release
  2. Version synchronization: The workflow automatically updates project versions to match the tag
  3. Automatic packaging: Creates release packages and updates the AutoUpdater XML
  4. GitHub releases: Automatically creates GitHub releases with generated notes
Running Different Projects
# Run the Web API
dotnet run --project Canon.API
# Run the Console Test Application 
dotnet run --project Canon.Test
# Run the Avalonia GUI Test Application
dotnet run --project Canon.Test.Avalonia
Compatibility
Tested Camera Models
  • Canon EOS R100 ✅
  • Canon T7 ✅
System Requirements
  • OS: Windows (x64)
  • Runtime: .NET 9 or newer
  • Dependencies: Canon EDSDK libraries (included)
Note: While this software has been tested with the above camera models, it should work with other Canon cameras that support the EDSDK. However, functionality may vary depending on the specific camera model and its supported features.
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
3 stars
Watchers
0 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 - dansleboby/CanonWebAPI · GitHub
Skip to content
BranchesTags
Repository files navigation
CanonWebAPI
⚠️ BETA SOFTWARE: This project is currently in beta stage. While functional, it may contain bugs and is subject to breaking changes. Use with caution in production environments.
A web API for remotely controlling Canon DSLR and mirrorless cameras. This project utilizes the Canon EDSDK to communicate with the camera and includes automatic update capabilities.
Features
  • Get camera information (e.g., camera name).
  • Get and set camera settings:

    • ISO Speed
    • Aperture
    • Shutter Speed
    • Exposure Compensation
    • White Balance
  • Take pictures and download them.
  • Live view streaming via MJPEG.
  • Trigger autofocus.
  • Retrieve the last taken picture from the camera.
  • Automatic updates via AutoUpdater.NET integration.
  • Version display in console on startup.
Project Structure
The solution is divided into the following projects:
  • Canon.API: An ASP.NET Core web application that exposes the camera controls as a RESTful API.
  • Canon.Core: A .NET library that wraps the Canon EDSDK, providing a higher-level interface to interact with the camera.
  • Canon.Test: A simple console application for testing the Canon.Core library.
  • Canon.Test.Avalonia: A desktop application built with Avalonia UI for testing camera functionalities.
  • EDSDK: Contains the necessary Canon EDSDK libraries (EDSDK.dll, EdsImage.dll).
Getting Started
Prerequisites
  • A compatible Canon camera (tested with Canon EOS R100 and Canon T7).
  • The camera connected to the computer via USB.
  • .NET 9 SDK (or newer).
  • The Canon EOS Utility software should not be running, as it can prevent this application from connecting to the camera.
  • Windows operating system (x64 architecture required).
Installation
  1. Clone this repository.
  2. Ensure the EDSDK folder, containing EDSDK.dll and EdsImage.dll, is present in the project's root directory. These files are essential for the Canon.Core library to communicate with the camera.
  3. Build the solution using Visual Studio or the dotnet build command.
  4. Run the Canon.API project. This will start the web server.
API Endpoints
The following endpoints are available once the Canon.API project is running:
MethodPathDescriptionRequest Body (Example)
GET/cameranameGets the connected camera's name.N/A
GET/isoGets the current ISO speed and a list of supported values.N/A
POST/isoSets the ISO speed.{"value": "100"}
GET/apertureGets the current aperture and a list of supported values.N/A
POST/apertureSets the aperture.{"value": "5.6"}
GET/shutterspeedGets the current shutter speed and a list of supported values.N/A
POST/shutterspeedSets the shutter speed.{"value": "1/125"}
GET/exposureGets the current exposure compensation and supported values.N/A
POST/exposureSets the exposure compensation.{"value": "+1"}
GET/whitebalanceGets the current white balance and supported values.N/A
POST/whitebalanceSets the white balance.{"value": "Auto"}
POST/takepictureTakes a picture and returns the JPEG image. The useAutoFocus query parameter (default true) can be used to control autofocus.N/A
GET/videostreamStarts an MJPEG live view stream.N/A
GET/latestpictureGets the last picture taken from the camera's memory.N/A
POST/autofocusTriggers the camera's autofocus mechanism.N/A
Automatic Updates
This application includes automatic update functionality powered by AutoUpdater.NET:
  • Automatic version checking on startup
  • Seamless updates without requiring admin privileges
  • Graceful shutdown handling for web server during updates
  • Updates are downloaded from GitHub releases automatically
Development & Building
Building from Source
# Clone the repository
git clone https://github.com/dansleboby/CanonWebAPI.git
cd CanonWebAPI
# Restore dependencies
dotnet restore CanonSDK.sln
# Build the solution
dotnet build CanonSDK.sln --configuration Release
# Run the API
dotnet run --project Canon.API
Creating Releases
This project uses automated GitHub Actions for releases:
  1. Tag-based releases: Push a tag like v1.0.0.9 to trigger automated build and release
  2. Version synchronization: The workflow automatically updates project versions to match the tag
  3. Automatic packaging: Creates release packages and updates the AutoUpdater XML
  4. GitHub releases: Automatically creates GitHub releases with generated notes
Running Different Projects
# Run the Web API
dotnet run --project Canon.API
# Run the Console Test Application 
dotnet run --project Canon.Test
# Run the Avalonia GUI Test Application
dotnet run --project Canon.Test.Avalonia
Compatibility
Tested Camera Models
  • Canon EOS R100 ✅
  • Canon T7 ✅
System Requirements
  • OS: Windows (x64)
  • Runtime: .NET 9 or newer
  • Dependencies: Canon EDSDK libraries (included)
Note: While this software has been tested with the above camera models, it should work with other Canon cameras that support the EDSDK. However, functionality may vary depending on the specific camera model and its supported features.
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
3 stars
Watchers
0 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 - dansleboby/CanonWebAPI · GitHub
Skip to content
BranchesTags
Repository files navigation
CanonWebAPI
⚠️ BETA SOFTWARE: This project is currently in beta stage. While functional, it may contain bugs and is subject to breaking changes. Use with caution in production environments.
A web API for remotely controlling Canon DSLR and mirrorless cameras. This project utilizes the Canon EDSDK to communicate with the camera and includes automatic update capabilities.
Features
  • Get camera information (e.g., camera name).
  • Get and set camera settings:

    • ISO Speed
    • Aperture
    • Shutter Speed
    • Exposure Compensation
    • White Balance
  • Take pictures and download them.
  • Live view streaming via MJPEG.
  • Trigger autofocus.
  • Retrieve the last taken picture from the camera.
  • Automatic updates via AutoUpdater.NET integration.
  • Version display in console on startup.
Project Structure
The solution is divided into the following projects:
  • Canon.API: An ASP.NET Core web application that exposes the camera controls as a RESTful API.
  • Canon.Core: A .NET library that wraps the Canon EDSDK, providing a higher-level interface to interact with the camera.
  • Canon.Test: A simple console application for testing the Canon.Core library.
  • Canon.Test.Avalonia: A desktop application built with Avalonia UI for testing camera functionalities.
  • EDSDK: Contains the necessary Canon EDSDK libraries (EDSDK.dll, EdsImage.dll).
Getting Started
Prerequisites
  • A compatible Canon camera (tested with Canon EOS R100 and Canon T7).
  • The camera connected to the computer via USB.
  • .NET 9 SDK (or newer).
  • The Canon EOS Utility software should not be running, as it can prevent this application from connecting to the camera.
  • Windows operating system (x64 architecture required).
Installation
  1. Clone this repository.
  2. Ensure the EDSDK folder, containing EDSDK.dll and EdsImage.dll, is present in the project's root directory. These files are essential for the Canon.Core library to communicate with the camera.
  3. Build the solution using Visual Studio or the dotnet build command.
  4. Run the Canon.API project. This will start the web server.
API Endpoints
The following endpoints are available once the Canon.API project is running:
MethodPathDescriptionRequest Body (Example)
GET/cameranameGets the connected camera's name.N/A
GET/isoGets the current ISO speed and a list of supported values.N/A
POST/isoSets the ISO speed.{"value": "100"}
GET/apertureGets the current aperture and a list of supported values.N/A
POST/apertureSets the aperture.{"value": "5.6"}
GET/shutterspeedGets the current shutter speed and a list of supported values.N/A
POST/shutterspeedSets the shutter speed.{"value": "1/125"}
GET/exposureGets the current exposure compensation and supported values.N/A
POST/exposureSets the exposure compensation.{"value": "+1"}
GET/whitebalanceGets the current white balance and supported values.N/A
POST/whitebalanceSets the white balance.{"value": "Auto"}
POST/takepictureTakes a picture and returns the JPEG image. The useAutoFocus query parameter (default true) can be used to control autofocus.N/A
GET/videostreamStarts an MJPEG live view stream.N/A
GET/latestpictureGets the last picture taken from the camera's memory.N/A
POST/autofocusTriggers the camera's autofocus mechanism.N/A
Automatic Updates
This application includes automatic update functionality powered by AutoUpdater.NET:
  • Automatic version checking on startup
  • Seamless updates without requiring admin privileges
  • Graceful shutdown handling for web server during updates
  • Updates are downloaded from GitHub releases automatically
Development & Building
Building from Source
# Clone the repository
git clone https://github.com/dansleboby/CanonWebAPI.git
cd CanonWebAPI
# Restore dependencies
dotnet restore CanonSDK.sln
# Build the solution
dotnet build CanonSDK.sln --configuration Release
# Run the API
dotnet run --project Canon.API
Creating Releases
This project uses automated GitHub Actions for releases:
  1. Tag-based releases: Push a tag like v1.0.0.9 to trigger automated build and release
  2. Version synchronization: The workflow automatically updates project versions to match the tag
  3. Automatic packaging: Creates release packages and updates the AutoUpdater XML
  4. GitHub releases: Automatically creates GitHub releases with generated notes
Running Different Projects
# Run the Web API
dotnet run --project Canon.API
# Run the Console Test Application 
dotnet run --project Canon.Test
# Run the Avalonia GUI Test Application
dotnet run --project Canon.Test.Avalonia
Compatibility
Tested Camera Models
  • Canon EOS R100 ✅
  • Canon T7 ✅
System Requirements
  • OS: Windows (x64)
  • Runtime: .NET 9 or newer
  • Dependencies: Canon EDSDK libraries (included)
Note: While this software has been tested with the above camera models, it should work with other Canon cameras that support the EDSDK. However, functionality may vary depending on the specific camera model and its supported features.
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
3 stars
Watchers
0 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 - dansleboby/CanonWebAPI · GitHub
Skip to content
BranchesTags
Repository files navigation
CanonWebAPI
⚠️ BETA SOFTWARE: This project is currently in beta stage. While functional, it may contain bugs and is subject to breaking changes. Use with caution in production environments.
A web API for remotely controlling Canon DSLR and mirrorless cameras. This project utilizes the Canon EDSDK to communicate with the camera and includes automatic update capabilities.
Features
  • Get camera information (e.g., camera name).
  • Get and set camera settings:

    • ISO Speed
    • Aperture
    • Shutter Speed
    • Exposure Compensation
    • White Balance
  • Take pictures and download them.
  • Live view streaming via MJPEG.
  • Trigger autofocus.
  • Retrieve the last taken picture from the camera.
  • Automatic updates via AutoUpdater.NET integration.
  • Version display in console on startup.
Project Structure
The solution is divided into the following projects:
  • Canon.API: An ASP.NET Core web application that exposes the camera controls as a RESTful API.
  • Canon.Core: A .NET library that wraps the Canon EDSDK, providing a higher-level interface to interact with the camera.
  • Canon.Test: A simple console application for testing the Canon.Core library.
  • Canon.Test.Avalonia: A desktop application built with Avalonia UI for testing camera functionalities.
  • EDSDK: Contains the necessary Canon EDSDK libraries (EDSDK.dll, EdsImage.dll).
Getting Started
Prerequisites
  • A compatible Canon camera (tested with Canon EOS R100 and Canon T7).
  • The camera connected to the computer via USB.
  • .NET 9 SDK (or newer).
  • The Canon EOS Utility software should not be running, as it can prevent this application from connecting to the camera.
  • Windows operating system (x64 architecture required).
Installation
  1. Clone this repository.
  2. Ensure the EDSDK folder, containing EDSDK.dll and EdsImage.dll, is present in the project's root directory. These files are essential for the Canon.Core library to communicate with the camera.
  3. Build the solution using Visual Studio or the dotnet build command.
  4. Run the Canon.API project. This will start the web server.
API Endpoints
The following endpoints are available once the Canon.API project is running:
MethodPathDescriptionRequest Body (Example)
GET/cameranameGets the connected camera's name.N/A
GET/isoGets the current ISO speed and a list of supported values.N/A
POST/isoSets the ISO speed.{"value": "100"}
GET/apertureGets the current aperture and a list of supported values.N/A
POST/apertureSets the aperture.{"value": "5.6"}
GET/shutterspeedGets the current shutter speed and a list of supported values.N/A
POST/shutterspeedSets the shutter speed.{"value": "1/125"}
GET/exposureGets the current exposure compensation and supported values.N/A
POST/exposureSets the exposure compensation.{"value": "+1"}
GET/whitebalanceGets the current white balance and supported values.N/A
POST/whitebalanceSets the white balance.{"value": "Auto"}
POST/takepictureTakes a picture and returns the JPEG image. The useAutoFocus query parameter (default true) can be used to control autofocus.N/A
GET/videostreamStarts an MJPEG live view stream.N/A
GET/latestpictureGets the last picture taken from the camera's memory.N/A
POST/autofocusTriggers the camera's autofocus mechanism.N/A
Automatic Updates
This application includes automatic update functionality powered by AutoUpdater.NET:
  • Automatic version checking on startup
  • Seamless updates without requiring admin privileges
  • Graceful shutdown handling for web server during updates
  • Updates are downloaded from GitHub releases automatically
Development & Building
Building from Source
# Clone the repository
git clone https://github.com/dansleboby/CanonWebAPI.git
cd CanonWebAPI
# Restore dependencies
dotnet restore CanonSDK.sln
# Build the solution
dotnet build CanonSDK.sln --configuration Release
# Run the API
dotnet run --project Canon.API
Creating Releases
This project uses automated GitHub Actions for releases:
  1. Tag-based releases: Push a tag like v1.0.0.9 to trigger automated build and release
  2. Version synchronization: The workflow automatically updates project versions to match the tag
  3. Automatic packaging: Creates release packages and updates the AutoUpdater XML
  4. GitHub releases: Automatically creates GitHub releases with generated notes
Running Different Projects
# Run the Web API
dotnet run --project Canon.API
# Run the Console Test Application 
dotnet run --project Canon.Test
# Run the Avalonia GUI Test Application
dotnet run --project Canon.Test.Avalonia
Compatibility
Tested Camera Models
  • Canon EOS R100 ✅
  • Canon T7 ✅
System Requirements
  • OS: Windows (x64)
  • Runtime: .NET 9 or newer
  • Dependencies: Canon EDSDK libraries (included)
Note: While this software has been tested with the above camera models, it should work with other Canon cameras that support the EDSDK. However, functionality may vary depending on the specific camera model and its supported features.
About
No description, website, or topics provided.
Resources
Readme
Activity
Stars
3 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages