Recherche avancée

Sur d’autres sites (11100)

• Unlocking the power of web analytics dashboards

  22 juillet, par Joe — Analytics Tips, App Analytics

  In the web analytics world, we have no shortage of data — clicks, views, scrolls, bounce rates — yet still struggle to extract valuable, actionable insights. There are facts and figures about any action anybody takes (or doesn’t take) when they visit your website, place an order or abandon their shopping cart. But all that data is often without context.

  That’s where dashboards come in : More than visual summaries, the right dashboards give context, reduce noise, and help us focus on what matters most — whether it’s boosting conversions, optimising campaigns, or monitoring data quality and compliance efforts.

  In this article, we’ll focus on :

  • The importance of data quality in web analytics dashboards
  • Different types of dashboards to use depending on your goals 
  • How to work with built-in dashboards in Matomo
  • How to customise them for your organisation’s needs

  Whether you’re building your first dashboard or refining a mature analytics strategy, this guide will help you get more out of your data.

  What is a web analytics dashboard ?

  A web analytics dashboard is an interactive interface that displays key website metrics and data visualisations in an easy-to-grasp format. It presents key data clearly and highlights potential problems, helping users quickly spot trends, patterns, and areas for improvement.

  Dashboards present data in charts, graphs and tables that are easier to understand and act upon. Users can usually drill down on individual elements for more detail, import other relevant data or adjust the time scale to get daily, weekly, monthly or seasonal views.

  Types of web analytics dashboards

  Web analytics dashboards may vary in the type of information they present and the website KPIs (key performance indicators) they track. However, sometimes the information can be the same or similar, but the context is what changes.

  Overview dashboard

  This offers a comprehensive overview of key metrics and KPIs. For example, it might show :

  • Traffic metrics, such as the total number of sessions, visits to the website, distinct users, total pages viewed and/or the average number of pages viewed per visit.
  • Engagement metrics, like average session duration, the bounce rate and/ or the exit rate by specific pages.
  • Audience metrics, including new vs. returning visitors, or visitor demographics such as age, gender or location. It might also show details of the specific device types used to access the website : desktop, mobile, or tablet.

  An overview dashboard might also include snapshots of some of the examples below.

  Acquisition dashboard

  This reveals how users arrive at a website. Although an overview dashboard can provide a snapshot of these metrics, a focused acquisition dashboard can break down website traffic even further. 

  They can reveal the percentages of traffic coming from organic search engines, social platforms, or users typing the URL directly. They can also show referrals from other websites and visitors clicking through from paid advertising sources. 

  An acquisition dashboard can also help measure campaign performance and reveal which marketing efforts are working and where to focus efforts for better results.

  Behavioural dashboard

  This dashboard shows how users interact with a website, including which pages get the most traffic and how long visitors stay before they leave. It also reveals which pages get the least traffic, highlighting where SEO optimisation or greater use of internal links may be needed.

  Behavioural dashboards can show a range of metrics, such as user engagement, navigation, page flow analysis, scroll depth, click patterns, form completion rates, event tracking, etc. 

  This behavioural data lets companies identify engaging vs. underperforming content, fix usability issues and optimise pages for better conversions. It may even show the data in heat maps, click maps or user path diagrams.

  Goals and ecommerce dashboard

  Dashboards of this type are mostly used by e-commerce websites. They’re useful because they track things like sales goal completions and revenue targets, as well as conversions, revenue, and user actions that deliver business results. 

  

  The typical metrics seen here are :

  • Goal tracking (aka conversions) in terms of completed user actions (form submissions, sign-ups, downloads, etc.) will provide funnel analysis and conversion rates. It’ll also give details about which traffic sources offer the most conversions.
  • Revenue tracking is provided via a combination of metrics. These include sales and revenue figures, average order value, top-selling items, revenue per product, and refund rates. It can also reveal how promotions, discounts and coupons affect total sales.
  • Shopping behaviour analysis tracks how users move from browsing to cart abandonment or purchase.

  These metrics help marketing teams measure campaign ROI. They also help identify high-value products and audiences and provide pointers for website refinement. For example, checkout flow optimisation might reduce abandonment.

  Technical performance dashboard

  This monitors a website’s technical health and performance metrics. It focuses on how a website’s infrastructure and backend health affect user experiences. It’ll track a lot of things, including :

  • Page load time
  • Server response time
  • DNS lookup time
  • Error rates
  • Mobile optimisation scores
  • Browser usage
  • Operating system distribution
  • Network performance
  • API response times
  • Core web vitals
  • Mobile usability issues

  This information helps organisations quickly fix issues that hurt SEO and conversions. It also helps to reduce errors that frustrate users, like checkout failures. Critically, it also helps to improve reliability and avoid downtime that can cost revenue.

  Geographic dashboard

  When an organisation wants to analyse user behaviour based on geographic location, this is the one to use. It reveals where website visitors are physically located and how their location influences their behaviour. Here’s what it tracks :

  • City, country/region 
  • Granular hotspots
  • Language preferences
  • Conversion rates by location
  • Bounce rates/engagement by location
  • Device type : Mobile vs. tablet vs desktop
  • Campaign performance by location
  • Paid ads effectiveness by location
  • Social media referrals by location
  • Load times by location

  Geographic dashboards allow companies to target marketing efforts at high-value regions. They also inform content localisation in terms of language, currency, or offers. And they help identify and address regional issues such as speed, payment methods, or cultural relevance.

  Custom segments dashboard

  This kind of dashboard allows specific subsets of an audience to be analysed based on specific criteria. For example, these subsets might include :

  • VIP customers
  • Mobile users
  • New vs. returning visitors
  • Logged-in users
  • Campaign responders
  • Product category enthusiasts. 

  What this dashboard reveals depends very much on what questions the user is trying to answer. It can provide actionable insight into why specific subsets of visitors or customers drop off at certain points. It allows specific metrics (bounce rate, conversions, etc.) to be compared across segments. 

  It can also track the performance of marketing campaigns across different audience segments, allowing marketing efforts to be tailored to serve high-potential segments. Its custom reports can also assist in problem-solving and testing hypotheses.

  

  Content performance dashboard

  This is useful for understanding how a website’s content engages users and drives business goals. Here’s what it tracks and why it matters :

  • Top-performing content
    • Most viewed pages
    • Highest time-on-page content
    • Most shared/linked content
  • Engagement metrics
    • Scroll depth (how far users read)
    • Video plays/podcast listens
    • PDF/downloads of gated content
  • Which content pieces lead to
    • Newsletter sign-ups
    • Demo requests
    • Product purchases
  • SEO health
    • Organic traffic per page
    • Keyword rankings for specific content
    • Pages with high exit rates
  • Content journey analysis
    • Entry pages that start user sessions
    • Common click paths through a site
    • Pages that often appear before conversions

  All this data helps improve website effectiveness. It lets organisations double down on what works, identify and replicate top-performing content and fix underperforming content. It can also identify content gaps, author performance and seasonal trends. The data then informs content strategy and optimisation efforts.

  The importance of data quality

  The fundamental reason we look at data is to make decisions that are informed by facts. So, it stands to reason that the quality of the underlying data is critical because it governs the quality of the information in the dashboard.

  And the data source for web analytics dashboards is often Google Analytics 4 (GA4), since it’s free and frequently installed by default on new websites. But this can be a problem because the free version of Google Analytics is limited and resorts to data sampling beyond a certain point. Let’s dig into that.

  Google Analytics 4 (GA4)

  It’s the default option for most organisations because it’s free, but GA4 has notable limitations that affect data accuracy and functionality. The big one is data sampling, which kicks in for large datasets (500,000+ events). This can skew reporting because the analysis is of subsets rather than complete data. 

  In addition, user privacy tools like ad blockers, tracking opt-outs, and disabled JavaScript can cause underreporting by 10-30%. GA4 also restricts data retention to 2-14 months and offers limited filtering and reduced control over data collection thresholds. Cross-domain tracking requires manual setup and lacks seamless integration. 

  One solution is to upgrade to Google Analytics 360 GA360, but it’s expensive. Pricing starts at $12,500/month (annual contract) plus $150,000 minimum yearly spend. The costs also scale with data volume, typically requiring $150,000−500,000 annually.

  

  Matomo’s built-in dashboards

  Matomo is a better solution for organisations needing unsampled data, longer data retention, and advanced attribution. It also provides functionality for enterprises to export their data and import it into Google BigQuery if that’s what they already use for analysis.

  Matomo Analytics takes a different approach to data quality. By focusing on privacy and data ownership, we ensure that businesses have full control over all of their data. Matomo also includes a range of built-in dashboards designed to meet the needs of different users. 

  The default options provide a starting point for tracking key metrics and gaining insight into their performance. They’re accessible by simply navigating to the reports section and selecting the relevant dashboard. These dashboards draw on raw data to provide more detailed and accurate analysis than is possible with GA4. And at a fraction of the price of GA360. 

  You can get Matomo completely free of charge as a self-hosted solution or via Matomo Cloud for a mere $29/month — vs. GA360’s $150k+/year. It also has other benefits :

  • 100% data ownership and no data sampling
  • Privacy compliance by design :
    • GDPR/CCPA-ready
    • No ad-blocker distortion
    • Cookieless tracking options
  • No data limits or retention caps
  • Advanced features without restriction :
    • Cross-domain tracking
    • Custom dimensions/metrics
    • Heatmaps/session recordings

  Customisation options

  Although Matomo’s default dashboards are powerful, the real value lies in the customisation options. These extensive and easy-to-use options empower users to tailor custom dashboards to their precise needs.

  Unlike GA4’s rigid layouts, Matomo offers drag-and-drop widgets to create, rearrange or resize reports effortlessly. You can :

  • Add 50+ pre-built widgets (e.g., traffic trends, conversion funnels, goal tracking) or create custom SQL/PHP widgets for unique metrics.
  • Segment data dynamically with filters (by country, device, campaign) and compare date ranges side-by-side.
  • Create white-label dashboards for client reporting, with custom logos, colours and CSS overrides.
  • Schedule automated PDF/email reports with personalised insights.
  • Build role-based dashboards (e.g., marketing vs. executive views) and restrict access to sensitive data.

  For developers, Matomo’s open API enables deep integrations (CRM, ERP, etc.) and custom visualisations via JavaScript. Self-hosted users can even modify the core user interface.

  Matomo : A fully adaptable analytics hub

  Web analytics dashboards can be powerful tools for visualising data, generating actionable insights and making better business decisions. But that’s only true as long as the underlying data is unrestricted and the analytics platform delivers high-quality data for analysis. 

  Matomo’s commitment to data quality and privacy sets it apart as a reliable source of accurate data to inform accurate and detailed insights. And the range of reporting options will meet just about any business need, often without any customisation.

  To see Matomo in action, watch this two-minute video. Then, when you’re ready to build your own, download Matomo On-Premise for free or start your 21-day free trial of Matomo Cloud — no credit card required.

• Why when using ffmpeg to create in real time avi video file from images the avi file is playing with purple noisy color ?

  30 juin 2015, par Brubaker Haim

  This is my Ffmpeg class i did some time ago

  using System;
  
  using System.Windows.Forms;
  
  using System.Collections.Generic;
  
  using System.Linq;
  
  using System.Text;
  
  using System.Threading.Tasks;
  
  using System.Drawing;
  
  using System.IO.Pipes;
  
  using System.Runtime.InteropServices;
  
  using System.Diagnostics;
  
  using System.IO;
  
  using DannyGeneral;
  
  
  
  namespace Manager
  
  {
  
      class Ffmpeg
  
      {
  
          NamedPipeServerStream p;
  
          String pipename = "mytestpipe";
  
          System.Diagnostics.Process process;
  
          string ffmpegFileName = "ffmpeg.exe";
  
          string workingDirectory;
  
  
  
          public Ffmpeg()
  
          {
  
              workingDirectory = Path.GetDirectoryName(Application.ExecutablePath);
  
              Logger.Write("workingDirectory: " + workingDirectory);
  
              if (!Directory.Exists(workingDirectory))
  
              {
  
                  Directory.CreateDirectory(workingDirectory);
  
              }
  
              ffmpegFileName = Path.Combine(workingDirectory, ffmpegFileName);
  
              Logger.Write("FfmpegFilename: " + ffmpegFileName);
  
          }
  
  
  
          public void Start(string pathFileName, int BitmapRate)
  
          {
  
              try
  
              {
  
  
  
                  string outPath = pathFileName;
  
                  p = new NamedPipeServerStream(pipename, PipeDirection.Out, 1, PipeTransmissionMode.Byte);
  
  
  
                  ProcessStartInfo psi = new ProcessStartInfo();
  
                  psi.WindowStyle = ProcessWindowStyle.Hidden;
  
                  psi.UseShellExecute = false;
  
                  psi.CreateNoWindow = false;
  
                  psi.FileName = ffmpegFileName;
  
                  psi.WorkingDirectory = workingDirectory;
  
                  psi.Arguments = @"-f rawvideo -pix_fmt yuv420p -video_size 1920x1080 -i \\.\pipe\mytestpipe -map 0 -c:v mpeg4 -r " + BitmapRate + " " + outPath;
  
                  process = Process.Start(psi);
  
                  process.EnableRaisingEvents = false;
  
                  psi.RedirectStandardError = true;
  
                  p.WaitForConnection();
  
              }
  
              catch (Exception err)
  
              {
  
                  Logger.Write("Exception Error: " + err.ToString());
  
              }
  
          }
  
  
  
          public void PushFrame(Bitmap bmp)
  
          {
  
              try
  
              {
  
                  int length;
  
                  // Lock the bitmap's bits.
  
                  //bmp = new Bitmap(1920, 1080);
  
                  Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
  
                  //Rectangle rect = new Rectangle(0, 0, 1280, 720);
  
                  System.Drawing.Imaging.BitmapData bmpData =
  
                      bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly,
  
                      bmp.PixelFormat);
  
  
  
                  int absStride = Math.Abs(bmpData.Stride);
  
                  // Get the address of the first line.
  
                  IntPtr ptr = bmpData.Scan0;
  
  
  
                  // Declare an array to hold the bytes of the bitmap.
  
                  //length = 3 * bmp.Width * bmp.Height;
  
                  length = absStride * bmpData.Height;
  
                  byte[] rgbValues = new byte[length];
  
  
  
                  //Marshal.Copy(ptr, rgbValues, 0, length);
  
                  int j = bmp.Height - 1;
  
                  for (int i = 0; i < bmp.Height; i++)
  
                  {
  
                      IntPtr pointer = new IntPtr(bmpData.Scan0.ToInt32() + (bmpData.Stride * j));
  
                      System.Runtime.InteropServices.Marshal.Copy(pointer, rgbValues, absStride * (bmp.Height - i - 1), absStride);
  
                      j--;
  
                  }
  
                  p.Write(rgbValues, 0, length);
  
                  bmp.UnlockBits(bmpData);
  
              }
  
              catch(Exception err)
  
              {
  
                  Logger.Write("Error: " + err.ToString());
  
              }
  
  
  
          }
  
  
  
          public void Close()
  
          {
  
              p.Close();
  
          }
  
      }
  
  }

  And i’m using it in form1 in a button click event :

  private void button1_Click(object sender, EventArgs e)
  
          {
  
              timer1.Start();
  
          }

  the directroy screenshots is where i’m taking a screenshot every 100ms in the timer1 tick event :

      ScreenShot shot = new ScreenShot();
  
      public static int counter = 0;
  
      private void timer1_Tick(object sender, EventArgs e)
  
      {
  
          counter++;
  
          shot.GetScreenShot(@"e:\screenshots\", "screenshot");
  
          if (counter == 1200)
  
          {
  
              timer1.Stop();
  
          }
  
      }

  I’m calling the method PushFrame from inside the ScreenShot class where i save the screenshots.

  Ffmpeg fmpeg;

  Then :

  fmpeg = new Ffmpeg();
  
  fmpeg.Start(@"e:\screenshots\test.avi", 25);

  And :

  public Bitmap GetScreenShot(string folder, string name)
  
      {
  
          _screenShot = new Bitmap(GetScreen());
  
          System.GC.Collect();
  
          System.GC.WaitForPendingFinalizers();
  
          string ingName = folder + name + Elgato_Video_Capture.counter.ToString("D6") + ".bmp";
  
          _screenShot.Save(ingName);
  
          fmpeg.PushFrame(_screenShot);
  
          _screenShot.Dispose();
  
  
  
          return _screenShot;
  
      }

  All the images on the hard disk are fine i can edit/open them and watch them no problems.
  They are also same size.

  The result in the end is one big avi file 1.08 GB size.
  But when i play it i see many windows running inside very fast and all painted with noisy purple color.

  Here a screenshot from the video file when playing it :

  avi file playing screenshot

  I think the problem is somewhere in the Ffmpeg class where i give parameters to the ffmpeg.exe

  psi.Arguments = @"-f rawvideo -pix_fmt yuv420p -video_size 1920x1080 -i \\.\pipe\mytestpipe -map 0 -c:v mpeg4 -r " + BitmapRate + " " + outPath;

  Not sure what make this avi file to look like that.

  This is the video file the result i got : https://www.youtube.com/watch?v=fdxPus-Xv1k&feature=youtu.be

• Why i'm getting strange video file when using ffmpeg and pipes to create video file in real time ?

  30 juin 2015, par Brubaker Haim

  The goal here is to create a compressed mp4 video file in real time.
  I’m saving screenshots as bitmaps type on my hard disk.
  And i want to create mp4 file and compress the mp4 video file in real time.

  The problem is the end the video file i get looks very strange.
  This is the result : Strange Video File

  The class that i’m using the ffmpeg with arguments.

  using System;
  
  using System.Windows.Forms;
  
  using System.Collections.Generic;
  
  using System.Linq;
  
  using System.Text;
  
  using System.Threading.Tasks;
  
  using System.Drawing;
  
  using System.IO.Pipes;
  
  using System.Runtime.InteropServices;
  
  using System.Diagnostics;
  
  using System.IO;
  
  using DannyGeneral;
  
  
  
  namespace Youtube_Manager
  
  {
  
      class Ffmpeg
  
      {
  
          NamedPipeServerStream p;
  
          String pipename = "mytestpipe";
  
          System.Diagnostics.Process process;
  
          string ffmpegFileName = "ffmpeg.exe";
  
          string workingDirectory;
  
  
  
          public Ffmpeg()
  
          {
  
              workingDirectory = Path.GetDirectoryName(Application.ExecutablePath);
  
              Logger.Write("workingDirectory: " + workingDirectory);
  
              if (!Directory.Exists(workingDirectory))
  
              {
  
                  Directory.CreateDirectory(workingDirectory);
  
              }
  
              ffmpegFileName = Path.Combine(workingDirectory, ffmpegFileName);
  
              Logger.Write("FfmpegFilename: " + ffmpegFileName);
  
          }
  
  
  
          public void Start(string pathFileName, int BitmapRate)
  
          {
  
              try
  
              {
  
  
  
                  string outPath = pathFileName;
  
                  p = new NamedPipeServerStream(pipename, PipeDirection.Out, 1, PipeTransmissionMode.Byte);
  
  
  
                  ProcessStartInfo psi = new ProcessStartInfo();
  
                  psi.WindowStyle = ProcessWindowStyle.Hidden;
  
                  psi.UseShellExecute = false;
  
                  psi.CreateNoWindow = false;
  
                  psi.FileName = ffmpegFileName;
  
                  psi.WorkingDirectory = workingDirectory;
  
                  psi.Arguments = @"-f rawvideo -pix_fmt yuv420p -video_size 1920x1080 -i \\.\pipe\mytestpipe -map 0 -c:v mpeg4 -r " + BitmapRate + " " + outPath;
  
                  //psi.Arguments = @"-framerate 1/5 -i -c:v libx264 -r 30 -pix_fmt yuv420p \\.\pipe\mytestpipe -map 0 -c:v mpeg4 -r" + BitmapRate + " " + outPath;
  
                  process = Process.Start(psi);
  
                  process.EnableRaisingEvents = false;
  
                  psi.RedirectStandardError = true;
  
                  p.WaitForConnection();
  
              }
  
              catch (Exception err)
  
              {
  
                  Logger.Write("Exception Error: " + err.ToString());
  
              }
  
          }
  
  
  
          public void PushFrame(Bitmap bmp)
  
          {
  
              try
  
              {
  
                  int length;
  
                  // Lock the bitmap's bits.
  
                  //bmp = new Bitmap(1920, 1080);
  
                  Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
  
                  //Rectangle rect = new Rectangle(0, 0, 1280, 720);
  
                  System.Drawing.Imaging.BitmapData bmpData =
  
                      bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly,
  
                      bmp.PixelFormat);
  
  
  
                  int absStride = Math.Abs(bmpData.Stride);
  
                  // Get the address of the first line.
  
                  IntPtr ptr = bmpData.Scan0;
  
  
  
                  // Declare an array to hold the bytes of the bitmap.
  
                  //length = 3 * bmp.Width * bmp.Height;
  
                  length = absStride * bmpData.Height;
  
                  byte[] rgbValues = new byte[length];
  
  
  
                  //Marshal.Copy(ptr, rgbValues, 0, length);
  
                  int j = bmp.Height - 1;
  
                  for (int i = 0; i < bmp.Height; i++)
  
                  {
  
                      IntPtr pointer = new IntPtr(bmpData.Scan0.ToInt32() + (bmpData.Stride * j));
  
                      System.Runtime.InteropServices.Marshal.Copy(pointer, rgbValues, absStride * (bmp.Height - i - 1), absStride);
  
                      j--;
  
                  }
  
                  p.Write(rgbValues, 0, length);
  
                  bmp.UnlockBits(bmpData);
  
              }
  
              catch(Exception err)
  
              {
  
                  Logger.Write("Error: " + err.ToString());
  
              }
  
  
  
          }
  
  
  
          public void Close()
  
          {
  
              p.Close();
  
          }
  
      }
  
  }

  Then i’m using the method PushFrame here in this class :

  public Bitmap GetScreenShot(string folder, string name)
  
      {
  
          _screenShot = new Bitmap(GetScreen());
  
          System.GC.Collect();
  
          System.GC.WaitForPendingFinalizers();
  
          string ingName = folder + name +  images.counter.ToString("D6") + ".bmp";
  
          _screenShot.Save(ingName,System.Drawing.Imaging.ImageFormat.Bmp);
  
          fmpeg.PushFrame(_screenShot);
  
          _screenShot.Dispose();
  
  
  
          return _screenShot;
  
      }

  The Bitmaps on the hard disk are fine i can edit/open see them.
  When using command prompt and manually type ffmpeg command it does compress and create a mp4 video file.

  But when using the Ffmpeg class i did with the PushFrame method it’s creating this strange video file.

  This is a link for my OneDrive with 10 screenshots images files for testing :

  screenshots rar

  Sample screenshot from the video file when playing the video file :
  Looks very choppy. The Bitmaps on the hard disk each one is 1920x1080 and Bit depth 32

  But it dosen’t look like that in the video file :

  

  This is the arguments i’m using :

  psi.Arguments = @"-f rawvideo -vcodec rawvideo -pix_fmt rgb24 -video_size 1920x1080 -i \\.\pipe\mytestpipe -map 0 -c:v mpeg4 -r " + BitmapRate + " " + outPath;

  The video size is very small 1.24 MB